public void TestBuilder()
        {
            int callCount = 0;

            string Builder(int id, DatabaseConnection connection)
            {
                callCount++;
                return("beep");
            }

            DatabaseConnection database = new DatabaseConnection();

            var reference = new ImmutableTableReference <string>(Builder, 4, database);

            // Creating a TableReference shall *NOT* execute the builder
            Assert.AreEqual(callCount, 0);

            Assert.AreEqual(reference.Identifier, 4);

            string text = reference.Reference;

            // Calling the Reference shall execute the builder
            Assert.AreEqual(text, "beep");
            Assert.AreEqual(callCount, 1);

            // The builder shall be executed only once no matter how many times we call the reference
            Assert.AreSame(reference.Reference, text);
            Assert.AreEqual(callCount, 1);


            database.Dispose();
        }
        public void TestReference()
        {
            ITableReference <string> subject = new ImmutableTableReference <string>(1, "beep");

            Assert.AreEqual(subject.Reference, "beep");
            Assert.AreEqual(subject.Identifier, 1);
        }
        public void TestExceptions()
        {
            Assert.ThrowsException <ArgumentNullException>(() => new ImmutableTableReference <string>(2, null));


            string Builder(int x, DatabaseConnection connection)
            {
                return("boop");
            }

            var database = new DatabaseConnection();

            Assert.ThrowsException <ArgumentNullException>(
                () => new ImmutableTableReference <string>(null, 5, null)
                );

            Assert.ThrowsException <ArgumentNullException>(
                // ReSharper disable once AccessToDisposedClosure
                () => new ImmutableTableReference <string>(Builder, 5, null)
                );

            Assert.ThrowsException <ArgumentNullException>(

                // ReSharper disable once AccessToDisposedClosure
                () => new ImmutableTableReference <string>(null, 5, database)
                );

            Assert.ThrowsException <ArgumentNullException>(
                () => new ImmutableTableReference <string>(5, null)
                );

            var reference = new ImmutableTableReference <string>((id, connection) => null, 4, database);

            Assert.AreEqual(reference.Reference, null);


            database.Dispose();
        }
Пример #4
0
        public void TestEmployeeInsertion()
        {
            var employee = new Employee
            {
                Cellphone   = "119400248922",
                Cpf         = "11111111111",
                Email       = "*****@*****.**",
                Gender      = "M",
                Name        = "bob",
                Password    = "******",
                Phone       = "40028922q,",
                BirthDate   = new DateTime(1970, 1, 1),
                Rfid        = "abc",
                Rg          = "12345",
                AccessLevel = 10,
                IsActive    = true,
                SocialName  = "bob",
                Role        = new TableReference <Role>
                {
                    Identifier = 7
                },
            };


            using var database = new DatabaseConnection();

            var reference = employee.Register(database);

            reference = new ImmutableTableReference <Employee>(Employee.From, reference.Identifier, database);

            Assert.AreEqual(reference.Identifier, employee.Id);

            foreach (PropertyInfo info in typeof(Employee).GetProperties().SkipLast(1))
            {
                Assert.AreEqual(info.GetValue(employee), info.GetValue(reference.Reference));
            }
        }