How do you get a #if conditional to work when unit testing?

Question

this is what I would like to be able to do.

/// <summary>
        /// Gets the session factory.
        /// </summary>
        /// <value>The session factory.</value>
        public ISessionFactory SessionFactory
        {
            get
            {
                if (_sessionFactory == null)
                {
#if(NUNIT)
                     _sessionFactory = Fluently.Configure()
                        .Database(SQLiteConfiguration.Standard
                                      .UsingFile(DbFile)
                                      .ShowSql())
                        .Mappings(m =>
                                  m.FluentMappings.AddFromAssemblyOf<ForeignFormat>())
                        .ExposeConfiguration(BuildSchema)
                        .BuildSessionFactory();

#else
                    _sessionFactory = Fluently.Configure()
                .Database(MsSqlConfiguration.MsSql2005
                              .ConnectionString(c => c
                                                         .Server(".\\sqlexpress")
                                                         .Database("mPort")
                                                         .TrustedConnection())
                                                         .ShowSql()
                                               )

                .Mappings(m => m
                                   .FluentMappings.AddFromAssemblyOf<ForeignFormat>())
                .BuildSessionFactory();
#endif
                }
                return _sessionFactory;

            }
        }

is it possible to #if conditional if you are running a unit test?

Answer 1

I would not recommend this methodology for unit testing. You should never put "test" code into a production file.

You should look into mocking objects to get the desired functionality from your BuildSessionFactory method.

Answer 2

I'd suggest mocking the db connection instead of littering #if/#else throught your code (even if it's only in this one place).

Answer 3

You shouldn't use #if sections to separate test code from production code. You want (and NEED) to test the production code.

It probably makes more sense to make the type/configuration of the database configurable. Dependency Injection is one way to do this, and the castle frameworks you seem to be using are designed to do this easily.

Dependency Injection is a technique to decouple the code you posted from the actual implementation of the database. This means you can inject a file or completely fake database class during test time.

Answer 4

#if is a compiler directive, so you'd need to compile your code differently when you're going to run tests vs. when you're going to run it "for real". You can define compiler flags in a project's build settings to do this.

But, I agree with everyone else who has suggested this isn't a good approach to take. Aside from the other issues people have mentioned, it's just going to be a pain to be constantly recompiling when you want to switch between running unit tests and running the real application.

Dependency injection or mocking would serve you much better.

Answer 5

Why don't you create a FakeSessionFactory in your unit tests in addition to your SessionFactory ?

In the unit tests, you pass your client class a FakeSessionFactory instance, and in your application, you provide him with a SessionFactory so that it really access the DB.

        public ISessionFactory SessionFactory
        {
            get
            {
                if (_sessionFactory == null)
                {
                    _sessionFactory = Fluently.Configure()
                .Database(MsSqlConfiguration.MsSql2005
                              .ConnectionString(c => c
                                                         .Server(".\\sqlexpress")
                                                         .Database("mPort")
                                                         .TrustedConnection())
                                                         .ShowSql()
                                               )

                .Mappings(m => m
                                   .FluentMappings.AddFromAssemblyOf<ForeignFormat>())
                .BuildSessionFactory();
                }
                return _sessionFactory;
            }
        }

        public ISessionFactory FakeSessionFactory
        {
            get
            {
                if (_sessionFactory == null)
                {
                     _sessionFactory = Fluently.Configure()
                        .Database(SQLiteConfiguration.Standard
                                      .UsingFile(DbFile)
                                      .ShowSql())
                        .Mappings(m =>
                                  m.FluentMappings.AddFromAssemblyOf<ForeignFormat>())
                        .ExposeConfiguration(BuildSchema)
                        .BuildSessionFactory();

                }
                return _sessionFactory;
            }
        }