Esempio n. 1
0
        public void ShouldNotFailOnIncorrectDocumentFromCouchDb(string docString)
        {
            var dbApiMock = new Mock <IDatabaseApi>();

            dbApiMock
            .Setup(a => a.Query(It.IsAny <ViewQuery>()))
            .Returns(
                (ViewQuery query) =>
                new ViewQueryResult(query: query, rows: new[] {
                new ViewResultRow(
                    new object[] { "key1", 0 }.ToJsonFragment(),
                    new { Title = "Object title", Subject = "some" }.ToJsonFragment(),
                    Entity.StandardDocId,
                    new Document(docString)
                    )
            }, totalCount: 1, offset: 0).ToTask <IViewQueryResult>()
                );
            var session     = new CouchSession(Default.Settings, Mock.Of <ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));
            var queryResult =
                session.Synchronously.Query <Entity>(new ViewQuery {
                IncludeDocs = true
            });

            Assert.Equal(1, queryResult.Count);
            Assert.Equal(1, queryResult.Rows.Count());
            Assert.Null(queryResult.First());
        }
Esempio n. 2
0
        public void ShouldCacheInstanceFromQuery()
        {
            var dbApiMock = new Mock <IDatabaseApi>();

            dbApiMock
            .Setup(a => a.Query(It.IsAny <ViewQuery>()))
            .Returns(
                (ViewQuery q) =>
                new ViewQueryResult(query: q, rows: new[] {
                new ViewResultRow(
                    new object[] { "key1", 0 }.ToJsonFragment(),
                    null,
                    Entity.StandardDocId,
                    Entity.CreateDocWithRevision()
                    )
            }, totalCount: 1, offset: 0).ToTask <IViewQueryResult>()
                );
            var session = new CouchSession(Default.Settings, Mock.Of <ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));

            Entity queriedEntity =
                session.Synchronously.Query <Entity>(new ViewQuery {
                IncludeDocs = true
            }).First();
            var loadedEntity = session.Synchronously.Load <Entity>(Entity.StandardEntityId);

            Assert.Same(queriedEntity, loadedEntity);
        }
Esempio n. 3
0
        public void ShouldQueryCochApiWithSameQueryObject()
        {
            ViewQuery sendQuery = null;

            var dbApiMock = new Mock <IDatabaseApi>(MockBehavior.Loose);

            dbApiMock
            .Setup(ca => ca.Query(It.IsAny <ViewQuery>()))
            .Returns(
                (ViewQuery query) => {
                sendQuery = query;
                return(new ViewQueryResult(
                           query,
                           new[] {
                    new ViewResultRow(
                        Entity.StandardDocId.ToJsonFragment(),
                        new { rev = Entity.StandardRevision }.ToJsonFragment(),
                        Entity.StandardDocId,
                        Entity.CreateDocWithRevision()
                        )
                },
                           totalCount: 1,
                           offset: 0).ToTask <IViewQueryResult>());
            });

            var session   = new CouchSession(Default.Settings, Mock.Of <ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));
            var viewQuery = new ViewQuery {
                ViewName = "_all_docs", IncludeDocs = true
            };

            session.Synchronously.Query <Entity>(viewQuery);

            Assert.Same(sendQuery, viewQuery);
        }
Esempio n. 4
0
        public void ShouldMapViewdataIfTypeIsCompatible()
        {
            var dbApiMock = new Mock <IDatabaseApi>();

            dbApiMock
            .Setup(a => a.Query(It.IsAny <ViewQuery>()))
            .Returns(
                (ViewQuery query) =>
                new ViewQueryResult(query: query, rows: new[] {
                new ViewResultRow(
                    new object[] { "key1", 0 }.ToJsonFragment(),
                    new { Title = "Object title", Subject = "some" }.ToJsonFragment(),
                    Entity.StandardDocId,
                    Entity.CreateDocWithRevision()
                    )
            }, totalCount: 1, offset: 0).ToTask <IViewQueryResult>()
                );
            var session     = new CouchSession(Default.Settings, Mock.Of <ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));
            var queryResult = session.Synchronously.Query <ViewData>(new ViewQuery());

            Assert.NotNull(queryResult);
            Assert.Equal(1, queryResult.Count);
            Assert.Equal(1, queryResult.TotalCount);

            var row = queryResult.First();

            Assert.NotNull(row);
            Assert.Equal("Object title", row.Title);
        }
Esempio n. 5
0
        public void ShouldBindDocumentsCorrectly()
        {
            Entity entity = Entity.CreateStandard();

            var dbApiMock = new Mock<IDatabaseApi>(MockBehavior.Loose);
            dbApiMock
                .Setup(ca => ca.Query(It.IsAny<ViewQuery>()))
                .Returns(
                    (ViewQuery query) => new ViewQueryResult(
                        query,
                        new[] {
                            new ViewResultRow(
                                Entity.StandardDocId.ToJsonFragment(),
                                new {rev = Entity.StandardRevision}.ToJsonFragment(),
                                Entity.StandardDocId,
                                Entity.CreateDocWithRevision()
                                )
                        },
                        totalCount: 1,
                        offset: 0
                        ).ToTask<IViewQueryResult>()
                );

            var session = new CouchSession(Default.Settings, Mock.Of<ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));
            IViewQueryResult<Entity> queryResult =
                session.Synchronously.Query<Entity>(new ViewQuery {ViewName = "_all_docs", IncludeDocs = true});

            Entity firstRow = queryResult.First();
            Assert.NotNull(firstRow);
            Assert.Equal(Entity.StandardEntityId, firstRow.Id);
            Assert.Equal(Entity.StandardRevision, firstRow.Revision);
            Assert.Equal(entity.Age, firstRow.Age);
            Assert.Equal(entity.Date, firstRow.Date);
            Assert.Equal(entity.Name, firstRow.Name);
        }
Esempio n. 6
0
 public void ShouldThrowOnNullEntity()
 {
     ISession session = new CouchSession(Default.Settings, Mock.Of<ICouchApi>());
     Assert.Throws<ArgumentNullException>(() => session.Save(null as Entity));
     Assert.Throws<ArgumentNullException>(() => session.Save(null as Entity[]));
     Assert.Throws<ArgumentNullException>(() => session.Save(Entity.CreateStandardWithoutRevision(), null));
 }
Esempio n. 7
0
        public void ShouldReturnSameInstanceWhenRequestingTwice()
        {
            var session = new CouchSession(Default.Settings, MockCouchApi());
            var entityA = session.Synchronously.Load <Entity>("doc1");
            var entityB = session.Synchronously.Load <Entity>("doc1");

            Assert.Same(entityA, entityB);
        }
Esempio n. 8
0
        public void ShouldThrowOnNullEntity()
        {
            ISession session = new CouchSession(Default.Settings, Mock.Of <ICouchApi>());

            Assert.Throws <ArgumentNullException>(() => session.Save(null as Entity));
            Assert.Throws <ArgumentNullException>(() => session.Save(null as Entity[]));
            Assert.Throws <ArgumentNullException>(() => session.Save(Entity.CreateStandardWithoutRevision(), null));
        }
Esempio n. 9
0
        public void ShouldThrowQueryExceptionIfNoIncludeDocsOptionAndEntityTypeParameter()
        {
            var session = new CouchSession(Default.Settings, Mock.Of <ICouchApi>());

            Assert.Throws <QueryException>(
                () => session.Synchronously.Query <Entity>(new ViewQuery {
                ViewName = "_all_docs"
            }));
        }
Esempio n. 10
0
        public void ShouldGenerateIdIfNoneSet()
        {
            var savingEntity = new Entity { Name = "Стас Гиркин" };
            ISession session = new CouchSession(Default.Settings, Mock.Of<ICouchApi>());
            session.Save(savingEntity);

            Assert.NotNull(savingEntity.Id);
            Assert.NotEqual(string.Empty, savingEntity.Id);
        }
Esempio n. 11
0
        public void x()
        {
            Documents.Configure <Port>((info, port) => port.Id = info.Id).UniqueConstraint = p => "--" + p.Slug;

            using (var session = new CouchSession(new Uri("http://127.0.0.1:5984"), "cruiseme"))
            {
                var results = session.Design("ports").ViewDocs <Port>("by_slug");
            }
        }
Esempio n. 12
0
        public void ShouldCacheFreashlySavedInstance()
        {
            var savingEntity = Entity.CreateStandardWithoutRevision();
            ISession session = new CouchSession(
                Default.Settings,
                Mock.Of<ICouchApi>(c => c.Db("testdb") == new Mock<IDatabaseApi>(MockBehavior.Strict).Object));
            session.Save(savingEntity);

            var loadedInstance = session.Synchronously.Load<Entity>(savingEntity.Id);
            Assert.Same(savingEntity, loadedInstance);
        }
Esempio n. 13
0
        public void ShouldGenerateIdIfNoneSet()
        {
            var savingEntity = new Entity {
                Name = "Стас Гиркин"
            };
            ISession session = new CouchSession(Default.Settings, Mock.Of <ICouchApi>());

            session.Save(savingEntity);

            Assert.NotNull(savingEntity.Id);
            Assert.NotEqual(string.Empty, savingEntity.Id);
        }
Esempio n. 14
0
        public void ShouldReturnSameInstancePerformingLoadAfterSave()
        {
            var entity = new Entity {
                Id = "doc1", Name = "Стас Гиркин"
            };
            var session = new CouchSession(Default.Settings, MockCouchApi());

            session.Save(entity);
            var loadedEntity = session.Synchronously.Load <Entity>("doc1");

            Assert.Same(entity, loadedEntity);
        }
Esempio n. 15
0
        public void ShouldStopReturnigDeletedEntityFromCache()
        {
            var      entity  = Entity.CreateStandardWithoutRevision();
            ISession session = new CouchSession(
                Default.Settings,
                Mock.Of <ICouchApi>(c => c.Db("testdb") == new Mock <IDatabaseApi>(MockBehavior.Strict).Object));

            session.Save(entity);
            session.Delete(entity);

            Assert.Null(session.Synchronously.Load <Entity>(entity.Id));
        }
Esempio n. 16
0
        public void get_known_db()
        {
            var url =
                "https://397ad533-6a4c-4a30-813f-bbf616b6d2c9.appharbor:6jLDgafReC50mf6tcgRmumJy@397ad533-6a4c-4a30-813f-bbf616b6d2c9.appharbor.cloudant.com";

            using (var session = new CouchSession(new Uri(url), "cruiseme"))
            {
                var db = session.Db.Get();

                Assert.That(db, Is.Not.Null);
                Assert.That(db.Name, Is.EqualTo(session.DatabaseName));
            }
        }
Esempio n. 17
0
        public void ShouldLoadDataCorrectlyIfNoRevisionPropertyFound()
        {
            var couchApi = Mock.Of<ICouchApi>(
                c => c.Db("testdb") ==  Mock.Of<IDatabaseApi>(
                    api => api.RequestDocument(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<AdditionalDocumentProperty>()) ==
                        EntityWithoutRevision.CreateDocumentWithRevision().ToTask()
            ));

            var loadedEntity = new CouchSession(Default.Settings, couchApi).Synchronously.Load<EntityWithoutRevision>("doc1");
            Assert.NotNull(loadedEntity);
            Assert.Equal("doc1", loadedEntity.Id);
            Assert.Equal("Стас Гиркин", loadedEntity.Name);
        }
Esempio n. 18
0
        public void ShouldCacheFreashlySavedInstance()
        {
            var      savingEntity = Entity.CreateStandardWithoutRevision();
            ISession session      = new CouchSession(
                Default.Settings,
                Mock.Of <ICouchApi>(c => c.Db("testdb") == new Mock <IDatabaseApi>(MockBehavior.Strict).Object));

            session.Save(savingEntity);

            var loadedInstance = session.Synchronously.Load <Entity>(savingEntity.Id);

            Assert.Same(savingEntity, loadedInstance);
        }
Esempio n. 19
0
 public void ShouldThrowOnSaveWithRevision()
 {
     ISession session = new CouchSession(Default.Settings, Mock.Of<ICouchApi>());
     Assert.Throws<ArgumentException>(() =>
         session.Save(
             new Entity {
                 Id = "doc1",
                 Revision = "42-1a517022a0c2d4814d51abfedf9bfee7",
                 Name = "Стас Гиркин"
             }
         )
     );
 }
Esempio n. 20
0
        public void test_cloudant_connection()
        {
            using (var couch =
                       new CouchSession(
                           new Uri(
                               "https://397ad533-6a4c-4a30-813f-bbf616b6d2c9.appharbor:6jLDgafReC50mf6tcgRmumJy@397ad533-6a4c-4a30-813f-bbf616b6d2c9.appharbor.cloudant.com"),
                           "cruiseme"))
            {
                var dbs = couch.Db.Get();

                Console.WriteLine(dbs);
            }
        }
Esempio n. 21
0
        public void ShouldLoadDataCorrectlyIfNoRevisionPropertyFound()
        {
            var couchApi = Mock.Of <ICouchApi>(
                c => c.Db("testdb") == Mock.Of <IDatabaseApi>(
                    api => api.RequestDocument(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <AdditionalDocumentProperty>()) ==
                    EntityWithoutRevision.CreateDocumentWithRevision().ToTask()
                    ));

            var loadedEntity = new CouchSession(Default.Settings, couchApi).Synchronously.Load <EntityWithoutRevision>("doc1");

            Assert.NotNull(loadedEntity);
            Assert.Equal("doc1", loadedEntity.Id);
            Assert.Equal("Стас Гиркин", loadedEntity.Name);
        }
        public void ShouldNotAllowNewChangeSaveOperationBeforePreviousOneCompletes()
        {
            var apiShouldEnter   = new AutoResetEvent(initialState: false);
            var bulkUpdateCalled = 0;

            IDictionary <string, DocumentInfo> returnInfo = new Dictionary <string, DocumentInfo> {
                { SimpleEntity.StandardDocId, new DocumentInfo(SimpleEntity.StandardDocId, "2-cc2c5ab22cfa4a0faad27a0cb9ca7968") }
            };

            var dbApiMock = new Mock <IDatabaseApi>();

            dbApiMock
            .Setup(couchApi => couchApi.BulkUpdate(It.IsAny <Action <IBulkUpdateBatch> >()))
            .Returns <Action <IBulkUpdateBatch> >(
                updater => Task.Factory.StartNew(
                    () => {
                apiShouldEnter.WaitOne();

                Interlocked.Increment(ref bulkUpdateCalled);
                updater(Mock.Of <IBulkUpdateBatch>());

                return(returnInfo);
            },
                    TaskCreationOptions.PreferFairness
                    )
                );

            ISession sesion = new CouchSession(Default.Settings, Mock.Of <ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));
            var      entity = SimpleEntity.CreateStandardWithoutRevision();

            sesion.Save(entity);
            var firstSaveChangesTask = sesion.StartSavingChanges();  // Enters API method

            Thread.Sleep(500);                                       //  Allowing first task to arrive to apiShouldEnter wating line first
            var secondSaveChangesTask = sesion.StartSavingChanges(); // Waits for first task to end

            Assert.Equal(0, bulkUpdateCalled);

            apiShouldEnter.Set();
            firstSaveChangesTask.WaitOrThrowOnTimeout();
            Assert.Equal(1, bulkUpdateCalled);


            entity.Age--;                       // Modifing entity for second save to be applicable
            apiShouldEnter.Set();               // Permitting second API method call to proceed
            secondSaveChangesTask.WaitOrThrowOnTimeout();
            Assert.Equal(2, bulkUpdateCalled);

            Assert.Equal("2-cc2c5ab22cfa4a0faad27a0cb9ca7968", entity.Revision);
        }
Esempio n. 23
0
        public void ShouldThrowOnSaveWithRevision()
        {
            ISession session = new CouchSession(Default.Settings, Mock.Of <ICouchApi>());

            Assert.Throws <ArgumentException>(() =>
                                              session.Save(
                                                  new Entity {
                Id       = "doc1",
                Revision = "42-1a517022a0c2d4814d51abfedf9bfee7",
                Name     = "Стас Гиркин"
            }
                                                  )
                                              );
        }
        public void ShouldDelegateChangesSaveToApi()
        {
            var couchApi = Mock.Of<ICouchApi>(
                c => c.Db("testdb") == Mock.Of<IDatabaseApi>(
                    d => d.BulkUpdate(It.IsAny<Action<IBulkUpdateBatch>>()) ==
                        new Dictionary<string, DocumentInfo>().ToTask<IDictionary<string, DocumentInfo>>()
                )
            );

            ISession sesion = new CouchSession(Default.Settings, couchApi);
            sesion.Save(SimpleEntity.CreateStandardWithoutRevision());
            sesion.SaveChanges();

            Mock.Get(couchApi.Db("testdb")).Verify(dbApi => dbApi.BulkUpdate(It.IsAny<Action<IBulkUpdateBatch>>()), Times.Once());
        }
        public void ShouldDelegateChangesSaveToApi()
        {
            var couchApi = Mock.Of <ICouchApi>(
                c => c.Db("testdb") == Mock.Of <IDatabaseApi>(
                    d => d.BulkUpdate(It.IsAny <Action <IBulkUpdateBatch> >()) ==
                    new Dictionary <string, DocumentInfo>().ToTask <IDictionary <string, DocumentInfo> >()
                    )
                );

            ISession sesion = new CouchSession(Default.Settings, couchApi);

            sesion.Save(SimpleEntity.CreateStandardWithoutRevision());
            sesion.SaveChanges();

            Mock.Get(couchApi.Db("testdb")).Verify(dbApi => dbApi.BulkUpdate(It.IsAny <Action <IBulkUpdateBatch> >()), Times.Once());
        }
Esempio n. 26
0
        public void ShouldNotThrowArgumentExceptionIfNoRevisionOnLoadedEntity()
        {
            string deletedId  = null;
            string deletedRev = null;

            var bulkUpdateBatchMock = new Mock <IBulkUpdateBatch>();

            bulkUpdateBatchMock
            .Setup(b => b.Delete(It.IsAny <string>(), It.IsAny <string>()))
            .Callback(
                (string id, string rev) => {
                deletedId  = id;
                deletedRev = rev;
            });

            var documentInfo = new DocumentInfo(EntityWithoutRevision.StandardDocId, "2-1a517022a0c2d4814d51abfedf9bfee7");

            var result    = documentInfo;
            var dbApiMock = new Mock <IDatabaseApi>();

            dbApiMock
            .Setup(ca => ca.BulkUpdate(It.IsAny <Action <IBulkUpdateBatch> >()))
            .Returns <Action <IBulkUpdateBatch> >(
                updateAction => {
                updateAction(bulkUpdateBatchMock.Object);
                return(new Dictionary <string, DocumentInfo> {
                    { result.Id, result }
                }
                       .ToTask <IDictionary <string, DocumentInfo> >());
            });
            dbApiMock
            .Setup(ca => ca.RequestDocument(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <AdditionalDocumentProperty>()))
            .Returns(EntityWithoutRevision.CreateDocumentWithRevision().ToTask());
            dbApiMock
            .Setup(ca => ca.Synchronously).Returns(new SynchronousDatabaseApi(dbApiMock.Object));

            var session = new CouchSession(Default.Settings, Mock.Of <ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));

            Assert.DoesNotThrow(() => {
                var entity = session.Synchronously.Load <EntityWithoutRevision>(EntityWithoutRevision.StandardEntityId);
                session.Delete(entity: entity);
                session.SaveChanges();
            });

            Assert.Equal(EntityWithoutRevision.StandardDocId, deletedId);
            Assert.Equal(EntityWithoutRevision.StandardRevision, deletedRev);
        }
        public void ShouldAssignNewlyUpdatedRevisionsToEntities()
        {
            var couchApi = Mock.Of<ICouchApi>(
                c => c.Db("testdb") == Mock.Of<IDatabaseApi>(
                    d => d.BulkUpdate(It.IsAny<Action<IBulkUpdateBatch>>()) ==
                        new Dictionary<string, DocumentInfo> {
                            { SimpleEntity.StandardDocId, new DocumentInfo(SimpleEntity.StandardDocId, "2-cc2c5ab22cfa4a0faad27a0cb9ca7968") }
                        }.ToTask<IDictionary<string, DocumentInfo>>()
                )
            );

            ISession sesion = new CouchSession(Default.Settings, couchApi);
            var entity = SimpleEntity.CreateStandardWithoutRevision();
            sesion.Save(entity);
            sesion.SaveChanges();

            Assert.Equal("2-cc2c5ab22cfa4a0faad27a0cb9ca7968", entity.Revision);
        }
Esempio n. 28
0
        public void ShouldNotThrowArgumentExceptionIfNoRevisionOnLoadedEntity()
        {
            string deletedId = null;
            string deletedRev = null;

            var bulkUpdateBatchMock = new Mock<IBulkUpdateBatch>();
            bulkUpdateBatchMock
                .Setup(b => b.Delete(It.IsAny<string>(), It.IsAny<string>()))
                .Callback(
                    (string id, string rev) => {
                        deletedId = id;
                        deletedRev = rev;
                    });

            var documentInfo = new DocumentInfo(EntityWithoutRevision.StandardDocId, "2-1a517022a0c2d4814d51abfedf9bfee7");

            var result = documentInfo;
            var dbApiMock = new Mock<IDatabaseApi>();
            dbApiMock
                .Setup(ca => ca.BulkUpdate(It.IsAny<Action<IBulkUpdateBatch>>()))
                .Returns<Action<IBulkUpdateBatch>>(
                    updateAction => {
                        updateAction(bulkUpdateBatchMock.Object);
                        return new Dictionary<string, DocumentInfo> {{result.Id, result}}
                            .ToTask<IDictionary<string, DocumentInfo>>();
                    });
            dbApiMock
                .Setup(ca => ca.RequestDocument(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<AdditionalDocumentProperty>()))
                .Returns(EntityWithoutRevision.CreateDocumentWithRevision().ToTask());
            dbApiMock
                .Setup(ca => ca.Synchronously).Returns(new SynchronousDatabaseApi(dbApiMock.Object));

            var session = new CouchSession(Default.Settings, Mock.Of<ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));

            Assert.DoesNotThrow(() => {
                var entity = session.Synchronously.Load<EntityWithoutRevision>(EntityWithoutRevision.StandardEntityId);
                session.Delete(entity: entity);
                session.SaveChanges();
            });

            Assert.Equal(EntityWithoutRevision.StandardDocId, deletedId);
            Assert.Equal(EntityWithoutRevision.StandardRevision, deletedRev);
        }
Esempio n. 29
0
        public void ShouldRequestCouchApiUsingDocumentIdRatherEntityId()
        {
            string requestedId = null;

            var dbApiMock = new Mock <IDatabaseApi>(MockBehavior.Loose);

            dbApiMock
            .Setup(ca => ca.RequestDocument(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <AdditionalDocumentProperty>()))
            .Returns(
                (string id, string revision, AdditionalDocumentProperty additionalProperties) => {
                requestedId = id;
                return(Entity.CreateDocWithRevision().ToTask());
            });
            var session = new CouchSession(Default.Settings, MockCouchApi(dbApiMock));

            session.Synchronously.Load <Entity>(Entity.StandardEntityId);

            Assert.Equal(Entity.StandardDocId, requestedId);
        }
        public void ShouldAssignNewlyUpdatedRevisionsToEntities()
        {
            var couchApi = Mock.Of <ICouchApi>(
                c => c.Db("testdb") == Mock.Of <IDatabaseApi>(
                    d => d.BulkUpdate(It.IsAny <Action <IBulkUpdateBatch> >()) ==
                    new Dictionary <string, DocumentInfo> {
                { SimpleEntity.StandardDocId, new DocumentInfo(SimpleEntity.StandardDocId, "2-cc2c5ab22cfa4a0faad27a0cb9ca7968") }
            }.ToTask <IDictionary <string, DocumentInfo> >()
                    )
                );

            ISession sesion = new CouchSession(Default.Settings, couchApi);
            var      entity = SimpleEntity.CreateStandardWithoutRevision();

            sesion.Save(entity);
            sesion.SaveChanges();

            Assert.Equal("2-cc2c5ab22cfa4a0faad27a0cb9ca7968", entity.Revision);
        }
Esempio n. 31
0
        public void ShouldLoadDataThroughtCouchApi()
        {
            var dbApiMock = new Mock<IDatabaseApi>(MockBehavior.Loose);
            dbApiMock
                .Setup(ca => ca.RequestDocument(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<AdditionalDocumentProperty>()))
                .Returns(
                    (string _, string __, AdditionalDocumentProperty ___) => Entity.CreateDocWithRevision().ToTask());
            dbApiMock
                .Setup(ca => ca.SaveDocument(It.IsAny<Document>()))
                .Returns(Entity.StandardDococumentInfo.ToTask());
            dbApiMock
                .Setup(ca => ca.Synchronously).Returns(() => new SynchronousDatabaseApi(dbApiMock.Object));

            var session = new CouchSession(Default.Settings, MockCouchApi(dbApiMock.Object));
            var loadedEntity = session.Synchronously.Load<Entity>(Entity.StandardEntityId);
            Assert.NotNull(loadedEntity);
            Assert.Equal(Entity.StandardEntityId, loadedEntity.Id);
            Assert.Equal(Entity.StandardRevision, loadedEntity.Revision);
            Assert.Equal("Стас Гиркин", loadedEntity.Name);
        }
Esempio n. 32
0
        public void ShouldBindDocumentsCorrectly()
        {
            Entity entity = Entity.CreateStandard();

            var dbApiMock = new Mock <IDatabaseApi>(MockBehavior.Loose);

            dbApiMock
            .Setup(ca => ca.Query(It.IsAny <ViewQuery>()))
            .Returns(
                (ViewQuery query) => new ViewQueryResult(
                    query,
                    new[] {
                new ViewResultRow(
                    Entity.StandardDocId.ToJsonFragment(),
                    new { rev = Entity.StandardRevision }.ToJsonFragment(),
                    Entity.StandardDocId,
                    Entity.CreateDocWithRevision()
                    )
            },
                    totalCount: 1,
                    offset: 0
                    ).ToTask <IViewQueryResult>()
                );

            var session = new CouchSession(Default.Settings, Mock.Of <ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));
            IViewQueryResult <Entity> queryResult =
                session.Synchronously.Query <Entity>(new ViewQuery {
                ViewName = "_all_docs", IncludeDocs = true
            });

            Entity firstRow = queryResult.First();

            Assert.NotNull(firstRow);
            Assert.Equal(Entity.StandardEntityId, firstRow.Id);
            Assert.Equal(Entity.StandardRevision, firstRow.Revision);
            Assert.Equal(entity.Age, firstRow.Age);
            Assert.Equal(entity.Date, firstRow.Date);
            Assert.Equal(entity.Name, firstRow.Name);
        }
Esempio n. 33
0
        public void ShouldLoadDataThroughtCouchApi()
        {
            var dbApiMock = new Mock <IDatabaseApi>(MockBehavior.Loose);

            dbApiMock
            .Setup(ca => ca.RequestDocument(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <AdditionalDocumentProperty>()))
            .Returns(
                (string _, string __, AdditionalDocumentProperty ___) => Entity.CreateDocWithRevision().ToTask());
            dbApiMock
            .Setup(ca => ca.SaveDocument(It.IsAny <Document>()))
            .Returns(Entity.StandardDococumentInfo.ToTask());
            dbApiMock
            .Setup(ca => ca.Synchronously).Returns(() => new SynchronousDatabaseApi(dbApiMock.Object));

            var session      = new CouchSession(Default.Settings, MockCouchApi(dbApiMock.Object));
            var loadedEntity = session.Synchronously.Load <Entity>(Entity.StandardEntityId);

            Assert.NotNull(loadedEntity);
            Assert.Equal(Entity.StandardEntityId, loadedEntity.Id);
            Assert.Equal(Entity.StandardRevision, loadedEntity.Revision);
            Assert.Equal("Стас Гиркин", loadedEntity.Name);
        }
Esempio n. 34
0
        public void ShouldUpdateChangedDocumentsOnFlush()
        {
            IDocument lastUpdatedDoc = null;
            var       totalSaveCount = 0;

            var couchApiMock = new Mock <ICouchApi>(MockBehavior.Loose);

            couchApiMock
            .Setup(ca => ca.SaveDocument(It.IsAny <IDocument>()))
            .Returns(
                (IDocument doc) => {
                lastUpdatedDoc = doc;
                totalSaveCount++;
                return(new DocumentInfo(entity.Id, "2-1a517022a0c2d4814d51abfedf9bfee7").ToTask());
            });
            couchApiMock
            .Setup(ca => ca.Synchronously).Returns(() => new SynchronousCouchApi(couchApiMock.Object));

            var session = new CouchSession(Default.Settings, couchApiMock.Object);

            session.Save(entity);
            entity.Name = "Artem Tikhomirov";
            session.SaveChanges();

            Assert.Equal(2, totalSaveCount);
            Assert.Equal("simpleEntity.doc1", lastUpdatedDoc.Id);
            Assert.Equal(
                new {
                _id  = "simpleEntity.doc1",
                _rev = "2-1a517022a0c2d4814d51abfedf9bfee7",
                type = "simpleEntity",
                name = "Artem Tikhomirov",
                age  = 42,
                date = "1957-04-10T00:00:00"
            }.ToDocument(),
                lastUpdatedDoc
                );
        }
Esempio n. 35
0
        public void ShouldUpdateChangedDocumentsOnFlush()
        {
            IDocument lastUpdatedDoc = null;
            var totalSaveCount = 0;

            var couchApiMock = new Mock<ICouchApi>(MockBehavior.Loose);
            couchApiMock
                .Setup(ca => ca.SaveDocument(It.IsAny<IDocument>()))
                .Returns(
                    (IDocument doc) => {
                        lastUpdatedDoc = doc;
                        totalSaveCount++;
                        return new DocumentInfo(entity.Id, "2-1a517022a0c2d4814d51abfedf9bfee7").ToTask();
                    });
            couchApiMock
                .Setup(ca => ca.Synchronously).Returns(() => new SynchronousCouchApi(couchApiMock.Object));

            var session = new CouchSession(Default.Settings, couchApiMock.Object);
            session.Save(entity);
            entity.Name = "Artem Tikhomirov";
            session.SaveChanges();

            Assert.Equal(2, totalSaveCount);
            Assert.Equal("simpleEntity.doc1", lastUpdatedDoc.Id);
            Assert.Equal(
                new {
                    _id = "simpleEntity.doc1",
                    _rev = "2-1a517022a0c2d4814d51abfedf9bfee7",
                    type = "simpleEntity",
                    name = "Artem Tikhomirov",
                    age = 42,
                    date = "1957-04-10T00:00:00"
                }.ToDocument(),
                lastUpdatedDoc
            );
        }
Esempio n. 36
0
        public void ShouldNotFailIfOnNullValueRowsFromCouchDB()
        {
            var dbApiMock = new Mock <IDatabaseApi>();

            dbApiMock
            .Setup(a => a.Query(It.IsAny <ViewQuery>()))
            .Returns(
                (ViewQuery query) =>
                new ViewQueryResult(query: query, rows: new[] {
                new ViewResultRow(
                    new object[] { "key1", 0 }.ToJsonFragment(),
                    null,
                    Entity.StandardDocId,
                    Entity.CreateDocWithRevision()
                    )
            }, totalCount: 1, offset: 0).ToTask <IViewQueryResult>()
                );
            var session = new CouchSession(Default.Settings, Mock.Of <ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));
            IViewQueryResult <ViewData> queryResult = session.Synchronously.Query <ViewData>(new ViewQuery());

            Assert.Equal(1, queryResult.Count);
            Assert.Equal(1, queryResult.Count());
            Assert.Null(queryResult.First());
        }
Esempio n. 37
0
        public void ShouldMapViewdataIfTypeIsCompatible()
        {
            var dbApiMock = new Mock<IDatabaseApi>();
            dbApiMock
                .Setup(a => a.Query( It.IsAny<ViewQuery>()))
                .Returns(
                    (ViewQuery query) =>
                        new ViewQueryResult(query: query, rows: new[] {
                            new ViewResultRow(
                                new object[] {"key1", 0}.ToJsonFragment(),
                                new {Title = "Object title", Subject = "some"}.ToJsonFragment(),
                                Entity.StandardDocId,
                                Entity.CreateDocWithRevision()
                                )
                        }, totalCount: 1, offset: 0).ToTask<IViewQueryResult>()
                );
            var session = new CouchSession(Default.Settings, Mock.Of<ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));
            var queryResult = session.Synchronously.Query<ViewData>(new ViewQuery());

            Assert.NotNull(queryResult);
            Assert.Equal(1, queryResult.Count);
            Assert.Equal(1, queryResult.TotalCount);

            var row = queryResult.First();
            Assert.NotNull(row);
            Assert.Equal("Object title", row.Title);
        }
        public void ShouldNotAllowAnyOperationBeforeChangeSaveOperationCompletes(string operationName)
        {
            // I know this test is ginormus, but it's pretty self-contained and simple to understand

            var saveChangesOperationShouldProceed = new AutoResetEvent(initialState: false);
            var saveChangesOperationStarted = new AutoResetEvent(initialState: false);
            var executedOperations = new List<string>();

            IDictionary<string, DocumentInfo> returnInfo = new Dictionary<string, DocumentInfo> {
                { SimpleEntity.StandardDocId, new DocumentInfo(SimpleEntity.StandardDocId, "2-cc2c5ab22cfa4a0faad27a0cb9ca7968") }
            };

            var dbApiMock = new Mock<IDatabaseApi>();
            dbApiMock
                .Setup(couchApi => couchApi.BulkUpdate(It.IsAny<Action<IBulkUpdateBatch>>()))
                .Returns<Action<IBulkUpdateBatch>>(
                    updater => Task.Factory.StartNew(
                        () => {
                            saveChangesOperationStarted.Set();
                            saveChangesOperationShouldProceed.WaitOne();
                            updater(Mock.Of<IBulkUpdateBatch>());
                            return returnInfo;
                        }
                    )
                );
            dbApiMock
                .Setup(api => api.Query(It.IsAny<ViewQuery>()))
                .Returns<ViewQuery>(
                    _ => {
                        lock (executedOperations)
                            executedOperations.Add("Query");
                        return ViewQueryResult.Empty.ToTask();
                    });
            dbApiMock
                .Setup(api => api.QueryLucene(It.IsAny<LuceneQuery>()))
                .Returns<LuceneQuery>(
                    _ => {
                        lock (executedOperations)
                            executedOperations.Add("QueryLucene");
                        return
                            LuceneQueryResult.Empty.ToTask();
                    });
            dbApiMock
                .Setup(api => api.RequestDocument(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<AdditionalDocumentProperty>()))
                .Returns<string, string, AdditionalDocumentProperty>(
                    (_, __, ___) => {
                        lock (executedOperations)
                            executedOperations.Add("RequestDocument");
                        return SimpleEntity.CreateDocument().ToTask();
                    });
            dbApiMock
                .Setup(api => api.RequestLastestDocumentRevision(It.IsAny<string>()))
                .Returns<string>(
                    _ => {
                        lock (executedOperations)
                            executedOperations.Add("RequestLastestDocumentRevision");
                        return SimpleEntity.StandardDocId.ToTask();
                    });
            dbApiMock
                .Setup(api => api.DeleteDocument(It.IsAny<string>(), It.IsAny<string>()))
                .Returns<string, string>(
                    (_, __) => {
                        lock (executedOperations)
                            executedOperations.Add("DeleteDocument");
                        return SimpleEntity.StandardDocumentInfo.ToTask();
                    });
            dbApiMock
                .Setup(api => api.SaveDocument(It.IsAny<Document>()))
                .Returns<Document>(
                    _ => {
                        lock (executedOperations)
                            executedOperations.Add("SaveDocument");
                        return SimpleEntity.StandardDocumentInfo.ToTask();
                    });

            ISession sesion = new CouchSession(Default.Settings, Mock.Of<ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));

            sesion.Save(SimpleEntity.CreateStandardWithoutRevision());
            var saveChangesOperation = sesion.StartSavingChanges();
            // Wating for StartSavingChanges to delegate execution to CouchAPI resetting session-wide wait handle
            saveChangesOperationStarted.WaitOne();

            var startOperationTask = Task.Factory.StartNew(
                () => {
                    Task operation = null;
                    switch (operationName)
                    {
                        case "load":
                            operation = sesion.Load<SimpleEntity>("doc1a");
                            break;
                        case "query":
                            operation =
                                sesion.Query<SimpleEntity>(
                                    new ViewQuery {
                                        DesignDocumentName = "dd1",
                                        ViewName = "byX",
                                        Key = "key1",
                                        IncludeDocs = true
                                    });
                            break;
                        case "fullTextQuery":
                            operation =
                                sesion.QueryLucene<SimpleEntity>(
                                    new LuceneQuery
                                    {
                                        DesignDocumentName = "dd1",
                                        IndexName = "byX",
                                        IncludeDocs = true,
                                        Query = "key1:2"
                                    });
                            break;
                    }
                    // ReSharper disable PossibleNullReferenceException
                    operation.WaitOrThrowOnTimeout();
                    // ReSharper restore PossibleNullReferenceException
                });

            Assert.True(
                executedOperations.Count == 0,
                string.Join(", ", executedOperations) + " operation(s) have executed before save changes operation completes");

            saveChangesOperationShouldProceed.Set();
            saveChangesOperation.WaitOrThrowOnTimeout();

            startOperationTask.WaitOrThrowOnTimeout();
            Assert.Equal(1, executedOperations.Count);
        }
        public void ShouldNotAllowNewChangeSaveOperationBeforePreviousOneCompletes()
        {
            var apiShouldEnter = new AutoResetEvent(initialState: false);
            var bulkUpdateCalled = 0;

            IDictionary<string, DocumentInfo> returnInfo = new Dictionary<string, DocumentInfo> {
                { SimpleEntity.StandardDocId, new DocumentInfo(SimpleEntity.StandardDocId, "2-cc2c5ab22cfa4a0faad27a0cb9ca7968") }
            };

            var dbApiMock = new Mock<IDatabaseApi>();
            dbApiMock
                .Setup(couchApi => couchApi.BulkUpdate(It.IsAny<Action<IBulkUpdateBatch>>()))
                .Returns<Action<IBulkUpdateBatch>>(
                    updater => Task.Factory.StartNew(
                        () => {

                            apiShouldEnter.WaitOne();

                            Interlocked.Increment(ref bulkUpdateCalled);
                            updater(Mock.Of<IBulkUpdateBatch>());

                            return returnInfo;
                        },
                        TaskCreationOptions.PreferFairness
                    )
                );

            ISession sesion = new CouchSession(Default.Settings, Mock.Of<ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));
            var entity = SimpleEntity.CreateStandardWithoutRevision();
            sesion.Save(entity);
            var firstSaveChangesTask = sesion.StartSavingChanges(); // Enters API method
            Thread.Sleep(500); //  Allowing first task to arrive to apiShouldEnter wating line first
            var secondSaveChangesTask = sesion.StartSavingChanges(); // Waits for first task to end

            Assert.Equal(0, bulkUpdateCalled);

            apiShouldEnter.Set();
            firstSaveChangesTask.WaitOrThrowOnTimeout();
            Assert.Equal(1, bulkUpdateCalled);

            entity.Age--;				    // Modifing entity for second save to be applicable
            apiShouldEnter.Set();   // Permitting second API method call to proceed
            secondSaveChangesTask.WaitOrThrowOnTimeout();
            Assert.Equal(2, bulkUpdateCalled);

            Assert.Equal("2-cc2c5ab22cfa4a0faad27a0cb9ca7968", entity.Revision);
        }
        public void ShouldNotAllowAnyOperationBeforeChangeSaveOperationCompletes(string operationName)
        {
            // I know this test is ginormus, but it's pretty self-contained and simple to understand

            var saveChangesOperationShouldProceed = new AutoResetEvent(initialState: false);
            var saveChangesOperationStarted       = new AutoResetEvent(initialState: false);
            var executedOperations = new List <string>();

            IDictionary <string, DocumentInfo> returnInfo = new Dictionary <string, DocumentInfo> {
                { SimpleEntity.StandardDocId, new DocumentInfo(SimpleEntity.StandardDocId, "2-cc2c5ab22cfa4a0faad27a0cb9ca7968") }
            };

            var dbApiMock = new Mock <IDatabaseApi>();

            dbApiMock
            .Setup(couchApi => couchApi.BulkUpdate(It.IsAny <Action <IBulkUpdateBatch> >()))
            .Returns <Action <IBulkUpdateBatch> >(
                updater => Task.Factory.StartNew(
                    () => {
                saveChangesOperationStarted.Set();
                saveChangesOperationShouldProceed.WaitOne();
                updater(Mock.Of <IBulkUpdateBatch>());
                return(returnInfo);
            }
                    )
                );
            dbApiMock
            .Setup(api => api.Query(It.IsAny <ViewQuery>()))
            .Returns <ViewQuery>(
                _ => {
                lock (executedOperations)
                    executedOperations.Add("Query");
                return(ViewQueryResult.Empty.ToTask());
            });
            dbApiMock
            .Setup(api => api.QueryLucene(It.IsAny <LuceneQuery>()))
            .Returns <LuceneQuery>(
                _ => {
                lock (executedOperations)
                    executedOperations.Add("QueryLucene");
                return
                (LuceneQueryResult.Empty.ToTask());
            });
            dbApiMock
            .Setup(api => api.RequestDocument(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <AdditionalDocumentProperty>()))
            .Returns <string, string, AdditionalDocumentProperty>(
                (_, __, ___) => {
                lock (executedOperations)
                    executedOperations.Add("RequestDocument");
                return(SimpleEntity.CreateDocument().ToTask());
            });
            dbApiMock
            .Setup(api => api.RequestLastestDocumentRevision(It.IsAny <string>()))
            .Returns <string>(
                _ => {
                lock (executedOperations)
                    executedOperations.Add("RequestLastestDocumentRevision");
                return(SimpleEntity.StandardDocId.ToTask());
            });
            dbApiMock
            .Setup(api => api.DeleteDocument(It.IsAny <string>(), It.IsAny <string>()))
            .Returns <string, string>(
                (_, __) => {
                lock (executedOperations)
                    executedOperations.Add("DeleteDocument");
                return(SimpleEntity.StandardDocumentInfo.ToTask());
            });
            dbApiMock
            .Setup(api => api.SaveDocument(It.IsAny <Document>()))
            .Returns <Document>(
                _ => {
                lock (executedOperations)
                    executedOperations.Add("SaveDocument");
                return(SimpleEntity.StandardDocumentInfo.ToTask());
            });

            ISession sesion = new CouchSession(Default.Settings, Mock.Of <ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));

            sesion.Save(SimpleEntity.CreateStandardWithoutRevision());
            var saveChangesOperation = sesion.StartSavingChanges();

            // Wating for StartSavingChanges to delegate execution to CouchAPI resetting session-wide wait handle
            saveChangesOperationStarted.WaitOne();

            var startOperationTask = Task.Factory.StartNew(
                () => {
                Task operation = null;
                switch (operationName)
                {
                case "load":
                    operation = sesion.Load <SimpleEntity>("doc1a");
                    break;

                case "query":
                    operation =
                        sesion.Query <SimpleEntity>(
                            new ViewQuery {
                        DesignDocumentName = "dd1",
                        ViewName           = "byX",
                        Key         = "key1",
                        IncludeDocs = true
                    });
                    break;

                case "fullTextQuery":
                    operation =
                        sesion.QueryLucene <SimpleEntity>(
                            new LuceneQuery
                    {
                        DesignDocumentName = "dd1",
                        IndexName          = "byX",
                        IncludeDocs        = true,
                        Query = "key1:2"
                    });
                    break;
                }
                // ReSharper disable PossibleNullReferenceException
                operation.WaitOrThrowOnTimeout();
                // ReSharper restore PossibleNullReferenceException
            });

            Assert.True(
                executedOperations.Count == 0,
                string.Join(", ", executedOperations) + " operation(s) have executed before save changes operation completes");

            saveChangesOperationShouldProceed.Set();
            saveChangesOperation.WaitOrThrowOnTimeout();

            startOperationTask.WaitOrThrowOnTimeout();
            Assert.Equal(1, executedOperations.Count);
        }
Esempio n. 41
0
        public void ShouldNotFailIfOnNullValueRowsFromCouchDB()
        {
            var dbApiMock = new Mock<IDatabaseApi>();
            dbApiMock
                .Setup(a => a.Query(It.IsAny<ViewQuery>()))
                .Returns(
                    (ViewQuery query) =>
                        new ViewQueryResult(query: query, rows: new[] {
                            new ViewResultRow(
                                new object[] {"key1", 0}.ToJsonFragment(),
                                null,
                                Entity.StandardDocId,
                                Entity.CreateDocWithRevision()
                                )
                        }, totalCount: 1, offset: 0).ToTask<IViewQueryResult>()
                );
            var session = new CouchSession(Default.Settings, Mock.Of<ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));
            IViewQueryResult<ViewData> queryResult = session.Synchronously.Query<ViewData>(new ViewQuery());

            Assert.Equal(1, queryResult.Count);
            Assert.Equal(1, queryResult.Count());
            Assert.Null(queryResult.First());
        }
Esempio n. 42
0
        public void ShouldReturnSameInstancePerformingLoadAfterSave()
        {
            var entity = new Entity { Id = "doc1", Name = "Стас Гиркин" };
            var session = new CouchSession(Default.Settings, MockCouchApi());
            session.Save(entity);
            var loadedEntity = session.Synchronously.Load<Entity>("doc1");

            Assert.Same(entity, loadedEntity);
        }
Esempio n. 43
0
        public void ShouldQueryCochApiWithSameQueryObject()
        {
            ViewQuery sendQuery = null;

            var dbApiMock = new Mock<IDatabaseApi>(MockBehavior.Loose);
            dbApiMock
                .Setup(ca => ca.Query(It.IsAny<ViewQuery>()))
                .Returns(
                    (ViewQuery query) => {
                        sendQuery = query;
                        return new ViewQueryResult(
                            query,
                            new[] {
                                new ViewResultRow(
                                    Entity.StandardDocId.ToJsonFragment(),
                                    new {rev = Entity.StandardRevision}.ToJsonFragment(),
                                    Entity.StandardDocId,
                                    Entity.CreateDocWithRevision()
                                    )
                            },
                            totalCount: 1,
                            offset: 0).ToTask<IViewQueryResult>();
                    });

            var session = new CouchSession(Default.Settings, Mock.Of<ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));
            var viewQuery = new ViewQuery {ViewName = "_all_docs", IncludeDocs = true};
            session.Synchronously.Query<Entity>(viewQuery);

            Assert.Same(sendQuery, viewQuery);
        }
Esempio n. 44
0
        public void ShouldNotFailOnIncorrectDocumentFromCouchDb(string docString)
        {
            var dbApiMock = new Mock<IDatabaseApi>();
            dbApiMock
                .Setup(a => a.Query(It.IsAny<ViewQuery>()))
                .Returns(
                    (ViewQuery query) =>
                        new ViewQueryResult(query: query, rows: new[] {
                            new ViewResultRow(
                                new object[] {"key1", 0}.ToJsonFragment(),
                                new {Title = "Object title", Subject = "some"}.ToJsonFragment(),
                                Entity.StandardDocId,
                                new Document(docString)
                                )
                        }, totalCount: 1, offset: 0).ToTask<IViewQueryResult>()
                );
            var session = new CouchSession(Default.Settings, Mock.Of<ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));
            var queryResult =
                session.Synchronously.Query<Entity>(new ViewQuery {IncludeDocs = true});

            Assert.Equal(1, queryResult.Count);
            Assert.Equal(1, queryResult.Rows.Count());
            Assert.Null(queryResult.First());
        }
Esempio n. 45
0
 public void ShouldThrowQueryExceptionIfNoIncludeDocsOptionAndEntityTypeParameter()
 {
     var session = new CouchSession(Default.Settings, Mock.Of<ICouchApi>());
     Assert.Throws<QueryException>(
         () => session.Synchronously.Query<Entity>(new ViewQuery {ViewName = "_all_docs"}));
 }
Esempio n. 46
0
        public void ShouldRequestCouchApiUsingDocumentIdRatherEntityId()
        {
            string requestedId = null;

            var dbApiMock = new Mock<IDatabaseApi>(MockBehavior.Loose);
            dbApiMock
                .Setup(ca => ca.RequestDocument(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<AdditionalDocumentProperty>()))
                .Returns(
                    (string id, string revision, AdditionalDocumentProperty additionalProperties) => {
                        requestedId = id;
                        return Entity.CreateDocWithRevision().ToTask();
                    });
            var session = new CouchSession(Default.Settings, MockCouchApi(dbApiMock));
            session.Synchronously.Load<Entity>(Entity.StandardEntityId);

            Assert.Equal(Entity.StandardDocId, requestedId);
        }
Esempio n. 47
0
 public void ShouldReturnSameInstanceWhenRequestingTwice()
 {
     var session = new CouchSession(Default.Settings, MockCouchApi());
     var entityA = session.Synchronously.Load<Entity>("doc1");
     var entityB = session.Synchronously.Load<Entity>("doc1");
     Assert.Same(entityA, entityB);
 }
Esempio n. 48
0
        public void ShouldCacheInstanceFromQuery()
        {
            var dbApiMock = new Mock<IDatabaseApi>();
            dbApiMock
                .Setup(a => a.Query(It.IsAny<ViewQuery>()))
                .Returns(
                    (ViewQuery q) =>
                        new ViewQueryResult(query: q, rows: new[] {
                            new ViewResultRow(
                                new object[] {"key1", 0}.ToJsonFragment(),
                                null,
                                Entity.StandardDocId,
                                Entity.CreateDocWithRevision()
                                )
                        }, totalCount: 1, offset: 0).ToTask<IViewQueryResult>()
                );
            var session = new CouchSession(Default.Settings, Mock.Of<ICouchApi>(c => c.Db("testdb") == dbApiMock.Object));

            Entity queriedEntity =
                session.Synchronously.Query<Entity>(new ViewQuery {IncludeDocs = true}).First();
            var loadedEntity = session.Synchronously.Load<Entity>(Entity.StandardEntityId);
            Assert.Same(queriedEntity, loadedEntity);
        }
Esempio n. 49
0
        public void ShouldStopReturnigDeletedEntityFromCache()
        {
            var entity = Entity.CreateStandardWithoutRevision();
            ISession session = new CouchSession(
                Default.Settings,
                Mock.Of<ICouchApi>(c => c.Db("testdb") == new Mock<IDatabaseApi>(MockBehavior.Strict).Object));
            session.Save(entity);
            session.Delete(entity);

            Assert.Null(session.Synchronously.Load<Entity>(entity.Id));
        }