Example #1
0
        public async Task Save_WithNoRecords_ReturnsSuccess()
        {
            var fakeLogger        = A.Fake <ILogger <AggregatorDao <ExampleRecord> > >();
            var fakeSaveOperation = A.Fake <Func <string, IDictionary <string, object>, Task <int> > >();

            var dao = new AggregatorDao <ExampleRecord>(
                fakeLogger,
                null,
                fakeSaveOperation
                );

            var records = new List <ExampleRecord>
            {
            };

            var settings = new AggregatorDao <ExampleRecord> .Settings
            {
                FieldNames            = new[] { "domain", "some_number" },
                TableName             = "example",
                UpdateStatements      = "some_number = some_number + values(some_number)",
                ParameterValuesMapper = r => new Dictionary <string, object>
                {
                    ["domain"]      = r.Domain,
                    ["some_number"] = r.SomeNumber
                }
            };

            var outcome = await dao.Save(records, settings);

            Assert.That(outcome, Is.SameAs(Outcome.EmptyRecords));

            A.CallTo(() => fakeSaveOperation(A <string> .Ignored, A <IDictionary <string, object> > .Ignored))
            .MustNotHaveHappened();
        }
Example #2
0
        public async Task Save_WithRecords_SavesAndReturnsSuccess()
        {
            string capturedSql = null;
            IDictionary <string, object> capturedParameters = null;

            var fakeLogger        = A.Fake <ILogger <AggregatorDao <ExampleRecord> > >();
            var fakeSaveOperation = A.Fake <Func <string, IDictionary <string, object>, Task <int> > >();

            A.CallTo(() => fakeSaveOperation.Invoke(A <string> .Ignored, A <IDictionary <string, object> > .Ignored))
            .Invokes((string sql, IDictionary <string, object> parameters) =>
            {
                capturedSql        = sql;
                capturedParameters = parameters;
            })
            .Returns(Task.FromResult(10));

            var dao = new AggregatorDao <ExampleRecord>(
                fakeLogger,
                null,
                fakeSaveOperation
                );

            var records = new List <ExampleRecord>
            {
                new ExampleRecord
                {
                    Id         = 1,
                    Domain     = "blah.com",
                    SomeNumber = 567
                },
                new ExampleRecord
                {
                    Id         = 1,
                    Domain     = "blah2.com",
                    SomeNumber = 5678
                },
                new ExampleRecord
                {
                    Id         = 1,
                    Domain     = "blah3.com",
                    SomeNumber = 56789
                },
            };

            var settings = new AggregatorDao <ExampleRecord> .Settings
            {
                FieldNames            = new[] { "domain", "some_number" },
                TableName             = "example",
                UpdateStatements      = "some_number = some_number + values(some_number)",
                ParameterValuesMapper = r => new Dictionary <string, object>
                {
                    ["domain"]      = r.Domain,
                    ["some_number"] = r.SomeNumber
                }
            };

            var expectedParameters = new Dictionary <string, object>
            {
                ["domain_0"]      = "blah.com",
                ["some_number_0"] = 567,
                ["domain_1"]      = "blah2.com",
                ["some_number_1"] = 5678,
                ["domain_2"]      = "blah3.com",
                ["some_number_2"] = 56789,
                ["record_id"]     = 1,
            };

            var outcome = await dao.Save(records, settings);

            Assert.That(outcome, Is.SameAs(Outcome.SavedSuccessfully));

            A.CallTo(() => fakeSaveOperation(A <string> .Ignored, A <IDictionary <string, object> > .Ignored))
            .MustHaveHappenedOnceExactly();

            Assert.That(capturedSql, Is.EqualTo(expectedSql));
            Assert.That(capturedParameters, Is.EquivalentTo(expectedParameters));
        }