Remove publish steps

.vscode/launch.json

@@ -0,0 +1,14 @@
+{
+   // Use IntelliSense to find out which attributes exist for C# debugging
+   // Use hover for the description of the existing attributes
+   // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+   "version": "0.2.0",
+   "configurations": [
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach",
+            "processId": "${command:pickProcess}"
+        }
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,22 @@
+{
+    "version": "0.1.0",
+    "command": "dotnet",
+    "isShellCommand": true,
+    "args": [],
+    "tasks": [
+        {
+            "taskName": "build",
+            "command": "powershell",
+            "options": {
+                "cwd": "${workspaceRoot}/build"
+            },           
+            "args": [
+                "./build.ps1",
+                "-ConsistencyLevel",
+                "Session"
+            ],
+            "isBuildCommand": true,
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

License.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 ASOS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1 +1,87 @@
-# SimpleEventStore
+# Simple Event Store
+
+Simple Event Store (SES) provides a lightweight event sourcing abstraction.
+
+## Key Features
+- Full support for async/await for all persistence engines
+- Optimistic concurrency for append operations
+- Reading streams forward
+
+## Persistence Engines
+SES supports the following
+- Azure Cosmos DB
+- In Memory
+
+All persistence engines run the same test scenarios to ensure feature parity.  At present only the Cosmos DB persistence engine should be considered for production usage.
+
+## Usage
+
+### Creation
+```csharp
+var storageEngine = new InMemoryStorageEngine();
+var eventStore = new EventStore(storageEngine);
+```
+Do not use storage engines directly, only interact with the event store using the EventStore class.  There should only be a single instance of the EventStore per process.  Creating transient instances will lead to a decrease in performance.
+
+### Appending Events
+```csharp
+var expectedRevision = 0;
+
+await eventStore.AppendToStream(streamId, expectedRevision, new EventData(Guid.NewGuid(), new OrderCreated(streamId)));
+```
+The expected stream revision would either be set to 0 for a new stream, or to the expected event number.  If the latest event number in the database differs then a concurrency exception will be thrown.
+
+### Reading Events
+```csharp
+var events = await eventStore.ReadStreamForwards(streamId, startPosition: 2, numberOfEventsToRead: 1);
+// or
+var events = await subject.ReadStreamForwards(streamId);
+```
+You can either read all events in a stream, or a subset of events.  Only read all events if you know the maximum size of a stream is going to be low and that you always need to read all events as part of your workload e.g. replaying events to project current state for a DDD aggregate.
+
+## Cosmos DB
+```csharp
+DocumentClient client; // Set this up as required
+
+// If UseCollection isn't specified, sensible defaults for development are used.
+// If UseSubscriptions isn't supplied the subscription feature is disabled.
+return await new AzureDocumentDbStorageEngineBuilder(client, databaseName)
+	.UseCollection(o =>
+   	{
+		o.ConsistencyLevel = consistencyLevelEnum;
+		o.CollectionRequestUnits = 400;
+	})
+	.UseLogging(o =>
+	{
+		o.Success = onSuccessCallback;
+	})
+	.UseTypeMap(new ConfigurableSerializationTypeMap()
+		.RegisterTypes(
+			typeof(OrderCreated).GetTypeInfo().Assembly,
+			t => t.Namespace.EndsWith("Events"),
+			t => t.Name))
+	.Build()
+	.Initialise();
+```
+### CollectionOptions
+Allows you to specify
+- The consistency level of the database
+- The default number of RUs when the collection is created
+- The collection name
+
+Only use one of the following consistency levels
+- Strong
+- Bounded Staleness - use this if you need to geo-replicate the database
+
+### UseLogging
+Sets up callbacks per Cosmos DB operation performed.  This is useful if you want to record per call data e.g. RU cost of each operation.
+
+### UseTypeMap
+Allows you to control the event body/metadata type names.  Built in implementations
+- DefaultSerializationTypeMap - uses the AssemblyQualifiedName of the type. (default)
+- ConfigurableSerializationTypeMap - provides full control.
+
+While the default implementation is simple, this isn't great for versioning as contract assembly version number changes will render events unreadable.  Therefore the configurable implementation or your own implementation is recommended.
+
+### Initialise
+Calling the operation creates the underlying collection based on the DatabaseOptions.  This ensures the required stored procedure is present too.  It is safe to call this multiple times.

build/build.cake

@@ -1,41 +1,101 @@
-#tool "nuget:?package=xunit.runner.console"
+#addin nuget:?package=Cake.Json&version=1.0.2.13
+#addin nuget:?package=Newtonsoft.Json&version=9.0.1
+
 //////////////////////////////////////////////////////////////////////
 // ARGUMENTS
 //////////////////////////////////////////////////////////////////////
 
 var target = Argument("target", "Default");
 var configuration = Argument("configuration", "Release");
+var uri = Argument("uri", "https://localhost:8081/");
+var authKey = Argument("authKey", "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==");
+var consistencyLevel = Argument("consistencyLevel", "BoundedStaleness");
+var buildVersion = Argument("buildVersion", "1.0.0");
 
 //////////////////////////////////////////////////////////////////////
 // PREPARATION
 //////////////////////////////////////////////////////////////////////
 
 // Define directories.
-var solutionFile = "../src/SimpleEventStore/SimpleEventStore.sln";
+var solutionDir = "../src/SimpleEventStore/";
+var solutionFile = solutionDir + "SimpleEventStore.sln";
+var testProjs = GetFiles(solutionDir + "**/*.Tests.csproj");
+var outputDir = "./nuget";
 
 //////////////////////////////////////////////////////////////////////
 // TASKS
 //////////////////////////////////////////////////////////////////////
 
-Task("Restore-NuGet-Packages")
+Task("Restore-Packages")
     .Does(() =>
 {
-    NuGetRestore(solutionFile);
+    DotNetCoreRestore(solutionDir);
+});
+
+Task("Clean")
+    .Does(() => 
+{
+    CleanDirectory(outputDir);
 });
 
 Task("Build")
-    .IsDependentOn("Restore-NuGet-Packages")
+    .IsDependentOn("Clean")
+    .IsDependentOn("Restore-Packages")
+    .Does(() =>
+{
+    DotNetCoreBuild(solutionFile, new DotNetCoreBuildSettings {
+        Configuration = configuration,
+        NoIncremental = true,
+        ArgumentCustomization = args => args.Append("/p:BuildVersion=" + buildVersion)
+    });
+});
+
+Task("Transform-Unit-Test-Config")
     .Does(() =>
 {
-      // Use MSBuild
-      MSBuild(solutionFile, settings => settings.SetConfiguration(configuration));
+    var documentDbTestConfigFiles = GetFiles(solutionDir + "SimpleEventStore.AzureDocumentDb.Tests/bin/" + configuration + "/**/appsettings.json");
+
+    foreach(var documentDbTestConfigFile in documentDbTestConfigFiles)
+    {
+        var configJson = ParseJsonFromFile(documentDbTestConfigFile);
+        configJson["Uri"] = uri;
+        configJson["AuthKey"] = authKey;
+        configJson["ConsistencyLevel"] = consistencyLevel;
+
+        SerializeJsonToFile(documentDbTestConfigFile, configJson);
+
+        Information("Transformed " + documentDbTestConfigFile);
+    }
 });
 
 Task("Run-Unit-Tests")
     .IsDependentOn("Build")
+    .IsDependentOn("Transform-Unit-Test-Config")
     .Does(() =>
 {
-    XUnit2("../src/**/bin/" + configuration + "/*.Tests.dll");
+    foreach(var testPath in testProjs)
+    {
+        DotNetCoreTest(testPath.FullPath, new DotNetCoreTestSettings { 
+                Configuration = configuration,
+                NoBuild = true
+        });
+    }
+});
+
+Task("Package")
+    .IsDependentOn("Build")
+    .IsDependentOn("Run-Unit-Tests")
+    .Does(() => 
+{
+    var settings = new DotNetCorePackSettings {
+        Configuration = configuration,
+        NoBuild = true,
+        OutputDirectory = outputDir,
+        ArgumentCustomization = args => args.Append("/p:BuildVersion=" + buildVersion)
+    };
+
+    DotNetCorePack("./../src/SimpleEventStore/SimpleEventStore/", settings);
+    DotNetCorePack("./../src/SimpleEventStore/SimpleEventStore.AzureDocumentDb/", settings);
 });
 
 //////////////////////////////////////////////////////////////////////
@@ -49,4 +109,4 @@ Task("Default")
 // EXECUTION
 //////////////////////////////////////////////////////////////////////
 
-RunTarget(target);
+RunTarget(target);

build/build.ps1

@@ -44,7 +44,14 @@ Param(
     [string]$Target = "Default",
     [ValidateSet("Release", "Debug")]
     [string]$Configuration = "Release",
-    [ValidateSet("Quiet", "Minimal", "Normal", "Verbose", "Diagnostic")]
+    # TODO: Tidy up and revert back to standard Cake bootstrapper, shouldn't need config in here
+    [string]$Uri = "https://localhost:8081/",
+    [string]$AuthKey = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==",
+    [string]$ConsistencyLevel = "BoundedStaleness",
+    [string]$BuildVersion = "1.0.0",
+    [string]$NugetSource,
+    [string]$NugetApiKey,
+    [ValidateSet("Quiet", "Minimal", "Normal", "Verbose", "Diagnostic")]    
     [string]$Verbosity = "Verbose",
     [switch]$Experimental,
     [Alias("DryRun","Noop")]
@@ -185,5 +192,5 @@ if (!(Test-Path $CAKE_EXE)) {
 
 # Start Cake
 Write-Host "Running build script..."
-Invoke-Expression "& `"$CAKE_EXE`" `"$Script`" -target=`"$Target`" -configuration=`"$Configuration`" -verbosity=`"$Verbosity`" $UseMono $UseDryRun $UseExperimental $ScriptArgs"
+Invoke-Expression "& `"$CAKE_EXE`" `"$Script`" -target=`"$Target`" -configuration=`"$Configuration`" -verbosity=`"$Verbosity`" -uri=$Uri -authKey=$AuthKey -consistencyLevel=$ConsistencyLevel -buildVersion=`"$BuildVersion`" -nugetSource=`"$NugetSource`" -nugetApiKey=`"$NugetApiKey`" $UseMono $UseDryRun $UseExperimental $ScriptArgs"
 exit $LASTEXITCODE

build/tools/packages.config

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-	<package id="Cake" version="0.17.0" />
+	<package id="Cake" version="0.20.0" />
 </packages>

src/SimpleEventStore/SimpleEventStore.AzureDocumentDb.Tests/AzureDocumentDBEventStoreInitializing.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using Microsoft.Azure.Documents;
+using Microsoft.Azure.Documents.Client;
+using Microsoft.Azure.Documents.Linq;
+using NUnit.Framework;
+
+namespace SimpleEventStore.AzureDocumentDb.Tests
+{
+    [TestFixture]
+    public class AzureDocumentDBEventStoreInitializing
+    {
+        private const string DatabaseName = "InitializeTests";
+
+        [OneTimeTearDown]
+        public async Task TearDownDatabase()
+        {
+            var client = DocumentClientFactory.Create(DatabaseName);
+            await client.DeleteDatabaseAsync(UriFactory.CreateDatabaseUri(DatabaseName));
+        }
+
+        [Test]
+        public async Task when_initializing_all_expected_resources_are_created()
+        {
+            var client = DocumentClientFactory.Create(DatabaseName);
+            var collectionName = "AllExpectedResourcesAreCreated_" + Guid.NewGuid();
+            var storageEngine = await StorageEngineFactory.Create(DatabaseName, o => o.CollectionName = collectionName);
+
+            await storageEngine.Initialise();
+
+            var database = (await client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(DatabaseName))).Resource;
+            var collection = (await client.ReadDocumentCollectionAsync(UriFactory.CreateDocumentCollectionUri(DatabaseName, collectionName))).Resource;
+            var storedProcedure = (await client.ReadStoredProcedureAsync(UriFactory.CreateStoredProcedureUri(DatabaseName, collectionName, TestConstants.AppendStoredProcedureName))).Resource;
+            var offer = client.CreateOfferQuery()
+                .Where(r => r.ResourceLink == collection.SelfLink)
+                .AsEnumerable()
+                .OfType<OfferV2>()
+                .Single();
+
+            Assert.That(offer.Content.OfferThroughput, Is.EqualTo(TestConstants.RequestUnits));
+            Assert.That(collection.DefaultTimeToLive, Is.Null);
+            Assert.That(collection.PartitionKey.Paths.Count, Is.EqualTo(1));
+            Assert.That(collection.PartitionKey.Paths.Single(), Is.EqualTo("/streamId"));
+            Assert.That(collection.IndexingPolicy.IncludedPaths.Count, Is.EqualTo(1));
+            Assert.That(collection.IndexingPolicy.IncludedPaths[0].Path, Is.EqualTo("/*"));
+            Assert.That(collection.IndexingPolicy.ExcludedPaths.Count, Is.EqualTo(2));
+            Assert.That(collection.IndexingPolicy.ExcludedPaths[0].Path, Is.EqualTo("/body/*"));
+            Assert.That(collection.IndexingPolicy.ExcludedPaths[1].Path, Is.EqualTo("/metadata/*"));
+        }
+
+        [Test]
+        public async Task when_initializing_with_a_time_to_live_it_is_set()
+        {
+            var ttl = 60;
+            var collectionName = "TimeToLiveIsSet_" + Guid.NewGuid();
+            var client = DocumentClientFactory.Create(DatabaseName);
+            var storageEngine = await StorageEngineFactory.Create(DatabaseName, o => 
+            {
+                o.CollectionName = collectionName;
+                o.DefaultTimeToLive = ttl;
+            });
+
+            await storageEngine.Initialise();
+
+            var collection = (await client.ReadDocumentCollectionAsync(UriFactory.CreateDocumentCollectionUri(DatabaseName, collectionName))).Resource;
+            Assert.That(collection.DefaultTimeToLive, Is.EqualTo(ttl));
+        }
+    }
+}

src/SimpleEventStore/SimpleEventStore.AzureDocumentDb.Tests/AzureDocumentDbEventStoreAppending.cs

@@ -1,13 +1,15 @@
 using System.Threading.Tasks;
+using NUnit.Framework;
 using SimpleEventStore.Tests;
 
 namespace SimpleEventStore.AzureDocumentDb.Tests
 {
+    [TestFixture]
     public class AzureDocumentDbEventStoreAppending : EventStoreAppending
     {
         protected override Task<IStorageEngine> CreateStorageEngine()
         {
-            return StorageEngineFactory.Create("AppendingTests"); ;
+            return StorageEngineFactory.Create("AppendingTests");
         }
     }
 }