public void GivenDb_WhenOnPrepareIsConfigured__AndExecuteIsCalled_CommandIsPrepared()
{
var fakeConnection = new FakeConnection();
var db = new Db(fakeConnection, new DbConfig(c => ((FakeCommand)c).Comment = "PREPARED", MappingConvention.OracleStyle, string.Empty));
db.Execute("");
Assert.AreEqual("PREPARED", fakeConnection.Commands.Single().Comment);
}
public void TestInitialConnectionPromptsAfterEachWrite()
{
string endl = Environment.NewLine;
var connection = new FakeConnection();
var session = new Session(connection);
// Send a prompt through the connection. (This should be asking which character to login, or to create a new one.)
var prompt = session.State.BuildPrompt();
Verify.IsTrue(prompt.Length > 0);
Verify.AreEqual(1, connection.FakeMessagesSent.Count);
connection.Reset();
session.Write("test 1", true);
Verify.AreEqual(1, connection.FakeMessagesSent.Count);
Verify.AreEqual("test 1" + endl + prompt, connection.FakeMessagesSent[0]);
connection.Reset();
session.Write("test 2", false);
Verify.AreEqual(1, connection.FakeMessagesSent.Count);
Verify.AreEqual(endl + "test 2", connection.FakeMessagesSent[0]);
connection.Reset();
session.Write("test 3a");
session.Write("test 3b");
Verify.AreEqual(2, connection.FakeMessagesSent.Count);
Verify.AreEqual("test 3a" + endl + prompt, connection.FakeMessagesSent[0]);
Verify.AreEqual(endl + "test 3b" + endl + prompt, connection.FakeMessagesSent[1]);
}
static void Main(string[] args)
{
ConsoleColor old = Console.ForegroundColor;
try{
var props = new ConnectionProperties();
using (var frm = new ConnectionDialog(props, true, Assembly.LoadFrom))
{
var result = frm.ShowDialog();
if (result != System.Windows.Forms.DialogResult.OK)
return;
}
var cxi = new FakeConnection();
new ConnectionPropertiesSerializer().Serialize(cxi.DriverData, props);
var driver = new MongoDynamicDataContextDriver();
List<Assembly> assemblies = props.AssemblyLocations.Select(Assembly.LoadFrom).ToList();
var code = driver.GetStaticCodeFiles()
.Concat(new string[] {driver.GenerateDynamicCode(props, assemblies, "", "driver")});
if(props.InitializationQuery != null)
code = code.Concat(new string[]{driver.GenerateCustomInitQuery(props.InitializationQuery, "driver")});
Console.ForegroundColor = ConsoleColor.DarkCyan;
Console.WriteLine("------------------------------------------------");
foreach (string s in code)
{
Console.WriteLine(s);
Console.WriteLine("------------------------------------------------");
}
Console.ForegroundColor = old;
using (var frm = new SaveFileDialog())
{
var result = frm.ShowDialog();
if (result == DialogResult.OK)
{
using (StreamWriter writer = new StreamWriter(frm.OpenFile()))
{
foreach (string s in code)
{
writer.WriteLine(s);
writer.WriteLine("---------------------------------------------------");
}
writer.Flush();
}
}
}
}catch(Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(ex);
}
finally{
Console.ForegroundColor = old;
}
}
public async Task StartCreatesAndOpensWebSocket()
{
var fakeWebSocketTransport = new FakeWebSocketTransport();
fakeWebSocketTransport.Setup("OpenWebSocket", () =>
{
var tcs = new TaskCompletionSource<object>();
tcs.TrySetResult(null);
return tcs.Task;
});
var fakeConnection = new FakeConnection
{
TransportConnectTimeout = new TimeSpan(0, 0, 0, 0, 100),
TotalTransportConnectTimeout = new TimeSpan(0, 0, 0, 0, 100),
Url = "http://fake.url",
Protocol = new Version(1, 42),
ConnectionToken = "MyConnToken",
MessageId = "MsgId"
};
// connect timeout unblocks this call hence the expected exception
await Assert.ThrowsAsync<TimeoutException>(
async () => await fakeWebSocketTransport.Start(fakeConnection, "test", CancellationToken.None));
Assert.Equal(1, fakeConnection.GetInvocations("Trace").Count());
Assert.Equal(1, fakeConnection.GetInvocations("PrepareRequest").Count());
var openWebSocketInvocations = fakeWebSocketTransport.GetInvocations("OpenWebSocket").ToArray();
Assert.Equal(1, openWebSocketInvocations.Length);
Assert.StartsWith(
"ws://fake.urlconnect/?clientProtocol=1.42&transport=webSockets&connectionData=test&connectionToken=MyConnToken&messageId=MsgId",
((Uri)openWebSocketInvocations[0][1]).AbsoluteUri);
}
public MigrationTaskRunnerTests()
{
_db = new FakeConnection();
//_db.Setup(d => d.BeginTransaction()).Returns(new FakeTransaction());
LogHelper.Register(new ConsoleLogger(), "Default");
_sb = new StringBuilder();
_runner = new MigrationTaskRunner(_db, LogHelper.DefaultLogger);
}
public void TestInitialConnectionStateIsNotDefaultState()
{
string endl = Environment.NewLine;
var connection = new FakeConnection();
var session = new Session(connection);
Verify.IsTrue(session.State is SessionState);
Verify.IsTrue(!(session.State is DefaultState), "The default session state should have been ConnectedState.");
}
public async Task When_Add_Succeeds_InsertAsync_Returns_Success()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.ADD_SUCCESS);
_connectionPool.AddConnection(connection);
var bucket = GetBucketForKey("key1");
var result = await bucket.InsertAsync("key1", "NA");
Assert.IsTrue(result.Success);
Assert.AreEqual(ResponseStatus.Success, result.Status);
}
public async void When_Key_Is_Found_GetAsync_Returns_True()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.GET_OPAQUE_5_SUCCESS);
_connectionPool.AddConnection(connection);
var bucket = GetBucketForKey("key1");
var result = await bucket.GetAsync<int>("key1");
Assert.IsTrue(result.Success);
Assert.AreEqual(ResponseStatus.Success, result.Status);
}
public void SpecificCommand()
{
var connection = new FakeConnection();
var cmdToReturn = new FakeCommand(new ScalarCommandResult("SELECT count(*) FROM users", null){Result = 201});
connection.Setup(cmdToReturn);
var cmd = connection.CreateCommand();
cmd.CommandText = "SELECT count(*) FROM users";
var result = cmd.ExecuteScalar();
Assert.Equal(201, result);
}
public void CreateModel_CreatesANewModel()
{
// Arrange
var connection = new FakeConnection(new RabbitServer());
// Act
var result = connection.CreateModel();
// Assert
Assert.That(connection.Models,Has.Count.EqualTo(1));
Assert.That(connection.Models,Is.EquivalentTo(new[]{result}));
}
public void Close_TimeoutArguments_ClosesTheConnection()
{
// Arrange
var connection = new FakeConnection(new RabbitServer());
// Act
connection.Close(timeout:2);
// Assert
Assert.That(connection.IsOpen, Is.False);
Assert.That(connection.CloseReason, Is.Not.Null);
}
public void Can_create_new_connection_lazily_using_given_connection_string()
{
using (var connection = new FakeConnection(
CreateConfiguration(e => e.ConnectionString = "Database=FrodoLives"), new ConnectionStringResolver(null)))
{
Assert.Equal(0, connection.CreateCount);
var dbConnection = connection.DbConnection;
Assert.Equal(1, connection.CreateCount);
Assert.Equal("Database=FrodoLives", dbConnection.ConnectionString);
}
}
public void Close_AllArguments_ClosesTheConnection()
{
// Arrange
var connection = new FakeConnection(new RabbitServer());
// Act
connection.Close(reasonCode: 3, reasonText: "foo",timeout:4);
// Assert
Assert.That(connection.IsOpen, Is.False);
Assert.That(connection.CloseReason.ReplyCode, Is.EqualTo(3));
Assert.That(connection.CloseReason.ReplyText, Is.EqualTo("foo"));
}
public void WithConnection_WhenSet_SetsTheUnderlyingConnection()
{
// Arrange
var factory = new FakeConnectionFactory();
var connection = new FakeConnection(new RabbitServer());
// Act
factory.WithConnection(connection);
// Assert
Assert.That(factory.Connection,Is.SameAs(connection));
}
public void CreateModel_MultipleTimes_CreatesManyModels()
{
// Arrange
var connection = new FakeConnection(new RabbitServer());
// Act
var result1 = connection.CreateModel();
var result2 = connection.CreateModel();
// Assert
Assert.That(connection.Models, Has.Count.EqualTo(2));
Assert.That(connection.Models, Is.EquivalentTo(new[] { result1, result2 }));
}
public void UnderlyingConnection_WithConnection_ReturnsConnection()
{
// Arrange
var factory = new FakeConnectionFactory();
var connection = new FakeConnection(new RabbitServer());
factory.WithConnection(connection);
// Act
var result = factory.UnderlyingConnection;
// Assert
Assert.That(result, Is.SameAs(connection));
}
public void Can_create_new_connection_lazily_using_given_connection_string()
{
using (var connection = new FakeConnection(
CreateOptions(new FakeOptionsExtension1 { ConnectionString = "Database=FrodoLives" })))
{
Assert.Equal(0, connection.CreateCount);
var dbConnection = connection.DbConnection;
Assert.Equal(1, connection.CreateCount);
Assert.Equal("Database=FrodoLives", dbConnection.ConnectionString);
}
}
public async void When_Lock_Acquired_GetWithLockReturns_Success()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.GET_WITH_LOCK_SUCCESS);
_connectionPool.AddConnection(connection);
var bucket = GetBucketForKey("key1");
var result = await bucket.GetWithLockAsync <string>("key1", new TimeSpan(0, 0, 0, 2));
Console.WriteLine(result.Message);
Assert.IsTrue(result.Success);
Assert.AreEqual(ResponseStatus.Success, result.Status);
}
public async void When_Key_Found_InsertAsync_Returns_KeyExists()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.INSERT_KEYEXISTS);
_connectionPool.AddConnection(connection);
var key = "When_Key_Found_InsertAsync_Returns_KeyExists";
var bucket = GetBucketForKey(key);
var result = await bucket.InsertAsync(key, "NA");
Assert.IsFalse(result.Success);
Assert.AreEqual(ResponseStatus.KeyExists, result.Status);
}
public async void Test_AppendAsync()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.INSERT_SUCCESS);
_connectionPool.AddConnection(connection);
var key = "Test_Append_Async";
var bucket = GetBucketForKey(key);
var result = await bucket.AppendAsync(key, "AB");
Assert.IsTrue(result.Success);
Assert.AreEqual(ResponseStatus.Success, result.Status);
}
public async Task When_Key_Does_Not_Exist_RemoveAsync_Returns_KeyNotFound()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.REMOVE_KEYNOTFOUND);
_connectionPool.AddConnection(connection);
var key = "When_Key_Does_Not_Exist_RemoveAsync_Returns_KeyNotFound";
var bucket = GetBucketForKey(key);
var result = await bucket.RemoveAsync(key);
Assert.IsFalse(result.Success);
Assert.AreEqual(ResponseStatus.KeyNotFound, result.Status);
}
public async void When_Key_Found_RemoveAsync_Returns_Success()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.REMOVE_SUCCESS);
_connectionPool.AddConnection(connection);
var key = "When_Key_Found_RemoveAsync_Returns_Success";
var bucket = GetBucketForKey(key);
var result = await bucket.RemoveAsync(key);
Assert.IsTrue(result.Success);
Assert.AreEqual(ResponseStatus.Success, result.Status);
}
public async void When_Key_Does_Not_Exist_InsertAsync_Succeeds()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.INSERT_SUCCESS);
_connectionPool.AddConnection(connection);
var key = "When_Key_Does_Not_Exist_InsertAsync_Succeeds";
var bucket = GetBucketForKey(key);
var result = await bucket.InsertAsync(key, "NA");
Assert.IsTrue(result.Success);
Assert.AreEqual(ResponseStatus.Success, result.Status);
}
public async Task When_NMV_Found_GetAsync_Will_Retry_Until_Timeout()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.GET_WITH_NMV);
_connectionPool.AddConnection(connection);
var bucket = GetBucketForKey("key1");
var result = await bucket.GetAsync <int>("key1");
Console.WriteLine(result.Message);
Assert.IsFalse(result.Success);
Assert.AreEqual(ResponseStatus.OperationTimeout, result.Status);
}
public void Can_create_new_connection_lazily_using_given_connection_string()
{
using (var connection = new FakeConnection(
CreateOptions(new FakeOptionsExtension1 {
ConnectionString = "Database=FrodoLives"
})))
{
Assert.Equal(0, connection.CreateCount);
var dbConnection = connection.DbConnection;
Assert.Equal(1, connection.CreateCount);
Assert.Equal("Database=FrodoLives", dbConnection.ConnectionString);
}
}
public async Task The_player_should_move_one_block_in_the_given_direction(
Direction towards,
string axis,
int expectedPosition)
{
var connection = new FakeConnection();
var player = new JavaPlayer(connection);
await player.SetPositionAsync(new Vector3(0, 0, 0));
await player.MoveAsync(towards);
var setPosition = connection.LastPosition.ParseCoordinates();
(axis == "X" ? setPosition.X : setPosition.Z).Should().Be(expectedPosition,
$"moving {towards} means decrementing along the {axis}-axes");
}
public void Can_create_new_connection_from_exsting_DbConnection()
{
var dbConnection = CreateDbConnectionMock("Database=FrodoLives").Object;
using (var connection = new FakeConnection(
CreateOptions(new FakeOptionsExtension1 {
Connection = dbConnection
})))
{
Assert.Equal(0, connection.CreateCount);
Assert.Same(dbConnection, connection.DbConnection);
Assert.Equal(0, connection.CreateCount);
}
}
public void Uses_connection_string_resolver()
{
var configuration = new Configuration
{
new MemoryConfigurationSource(
new Dictionary <string, string>
{
{ "Data:Lobsang:ConnectionString", "Database=DatumEarth" }
})
};
using (var connection = new FakeConnection(
CreateConfiguration(e => e.ConnectionString = "Lobsang"), new ConnectionStringResolver(configuration)))
{
Assert.Equal("Database=DatumEarth", connection.ConnectionString);
}
}
public async Task ReconnectRetriesReconnectingIfStartingWebSocketThrows()
{
var fakeConnection = new FakeConnection
{
LastActiveAt = DateTime.UtcNow,
ReconnectWindow = new TimeSpan(0, 0, 15),
Url = "http://fakeserver/"
};
fakeConnection.Setup("ChangeState",
() =>
{
fakeConnection.State = ConnectionState.Reconnecting;
return(true);
});
var fakeWebSocketTransport = new FakeWebSocketTransport
{
ReconnectDelay = new TimeSpan(0, 0, 0, 1)
};
var openWebSocketInvoked = false;
var exception = new Exception();
fakeWebSocketTransport.Setup <Task>("OpenWebSocket", () =>
{
if (!openWebSocketInvoked)
{
openWebSocketInvoked = true;
throw exception;
}
var tcs = new TaskCompletionSource <object>();
tcs.TrySetResult(null);
return(tcs.Task);
});
await fakeWebSocketTransport.Reconnect(fakeConnection, null);
Assert.Equal(2, fakeWebSocketTransport.GetInvocations("OpenWebSocket").Count());
var onErrorInvocations = fakeConnection.GetInvocations("OnError").ToArray();
Assert.Equal(1, onErrorInvocations.Length);
Assert.Same(exception, onErrorInvocations[0][0]);
Assert.Equal(1, fakeConnection.GetInvocations("OnReconnected").Count());
}
public async Task InCaseOfExceptionStartInvokesOnFailureAndThrowsOriginalException()
{
var fakeConnection = new FakeConnection { TotalTransportConnectTimeout = new TimeSpan(0, 0, 10)};
var fakeWebSocketTransport = new FakeWebSocketTransport();
var expectedException = new Exception("OpenWebSocket failed.");
fakeWebSocketTransport.Setup<Task>("OpenWebSocket", () =>
{
throw expectedException;
});
Assert.Same(expectedException,
await Assert.ThrowsAsync<Exception>(
async () => await fakeWebSocketTransport.Start(fakeConnection, null, CancellationToken.None)));
Assert.Equal(1, fakeWebSocketTransport.GetInvocations("OnStartFailed").Count());
}
public void SpecificCommand()
{
var connection = new FakeConnection();
var cmdToReturn = new FakeCommand(new ScalarCommandResult("SELECT count(*) FROM users", null)
{
Result = 201
});
connection.Setup(cmdToReturn);
var cmd = connection.CreateCommand();
cmd.CommandText = "SELECT count(*) FROM users";
var result = cmd.ExecuteScalar();
Assert.Equal(201, result);
}
public void Existing_connection_can_start_in_opened_state()
{
var connectionMock = CreateDbConnectionMock("Database=FrodoLives");
connectionMock.Setup(m => m.State).Returns(ConnectionState.Open);
using (var connection = new FakeConnection(
CreateOptions(new FakeOptionsExtension1 {
Connection = connectionMock.Object
})))
{
Assert.Equal(0, connection.CreateCount);
connection.Open();
Assert.Equal(0, connection.CreateCount);
connectionMock.Verify(m => m.Open(), Times.Never);
connection.Open();
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Never);
connection.Close();
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Never);
connectionMock.Verify(m => m.Close(), Times.Never);
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Never);
connectionMock.Verify(m => m.Close(), Times.Never);
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Never);
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Never);
connectionMock.Verify(m => m.Close(), Times.Never);
}
}
public void Existing_connection_is_opened_and_closed_when_necessary()
{
var connectionMock = CreateDbConnectionMock("Database=FrodoLives");
connectionMock.Setup(m => m.State).Returns(ConnectionState.Closed);
using (var connection = new FakeConnection(
CreateOptions(new FakeOptionsExtension1 {
Connection = connectionMock.Object
})))
{
Assert.Equal(0, connection.CreateCount);
connection.Open();
Assert.Equal(0, connection.CreateCount);
connectionMock.Verify(m => m.Open(), Times.Once);
connection.Open();
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Once);
connection.Close();
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Never);
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Once);
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Exactly(2));
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Exactly(2));
connectionMock.Verify(m => m.Close(), Times.Exactly(2));
}
}
public void ToList_should_fill_the_list()
{
var connection = new FakeConnection()
{
CurrentState = ConnectionState.Open
};
var table = new FakeTable(new String[] { "Id" }, new object[][] { new object[] { 1 }, });
var result = new CommandResult[] { new ReaderCommandResult {
Result = new FakeDataReader(table)
} };
var cmd = new FakeCommand(connection, result);
cmd.CommandText = "Hello";
var actual = cmd.ToList <Tentity>(new TentityMapper());
actual[0].Id.Should().Be("1");
}
public CommandResult EmulateUsingLog()
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.Title = "Emulation Using Log";
dlg.Multiselect = false;
if (GCUtil.ShowModalDialog(_frame, dlg) == DialogResult.OK)
{
//エミュレートによるテスト
FakeConnection fc = new FakeConnection(TCPTerminalParam.Fake);
//!!new ConnectionTag()はpublicにしたくない
AddNewTerminal(new ConnectionTag(fc));
TestUtil.EmulateWithLog(dlg.FileName, GEnv.Connections.FindTag(fc));
return(CommandResult.Success);
}
return(CommandResult.Cancelled);
}
public void AutomaticResult()
{
var table = new FakeTable(new[]
{
new object[] {1, "jonas"},
new object[] {2, "arne"},
});
var connection = new FakeConnection();
connection.Setup(new FakeCommand(table));
var cmd = connection.CreateCommand();
cmd.CommandText = "SELECT Id, UserName FROM users";
var result = cmd.ExecuteReader();
Assert.True(result.Read());
Assert.Equal(1, (int)result[0]);
Assert.Equal("jonas", result[1]);
}
public async Task Lazy_connection_is_async_opened_and_closed_when_necessary()
{
using (var connection = new FakeConnection(
CreateOptions(new FakeOptionsExtension1 {
ConnectionString = "Database=FrodoLives"
})))
{
Assert.Equal(0, connection.CreateCount);
var cancellationToken = new CancellationTokenSource().Token;
await connection.OpenAsync(cancellationToken);
Assert.Equal(1, connection.CreateCount);
var connectionMock = Mock.Get(connection.DbConnection);
connectionMock.Verify(m => m.OpenAsync(cancellationToken), Times.Once);
await connection.OpenAsync(cancellationToken);
await connection.OpenAsync(cancellationToken);
connectionMock.Verify(m => m.OpenAsync(It.IsAny <CancellationToken>()), Times.Once);
connection.Close();
connection.Close();
connectionMock.Verify(m => m.OpenAsync(It.IsAny <CancellationToken>()), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Never);
connection.Close();
connectionMock.Verify(m => m.OpenAsync(It.IsAny <CancellationToken>()), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Once);
await connection.OpenAsync(cancellationToken);
connectionMock.Verify(m => m.OpenAsync(cancellationToken), Times.Exactly(2));
connection.Close();
connectionMock.Verify(m => m.OpenAsync(cancellationToken), Times.Exactly(2));
connectionMock.Verify(m => m.Close(), Times.Exactly(2));
}
}
public void Existing_connection_can_start_in_opened_state()
{
var connectionMock = CreateDbConnectionMock("Database=FrodoLives");
connectionMock.Setup(m => m.State).Returns(ConnectionState.Open);
using (var connection = new FakeConnection(
CreateConfiguration(e => e.Connection = connectionMock.Object), new ConnectionStringResolver(null)))
{
Assert.Equal(0, connection.CreateCount);
connection.Open();
Assert.Equal(0, connection.CreateCount);
connectionMock.Verify(m => m.Open(), Times.Never);
connection.Open();
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Never);
connection.Close();
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Never);
connectionMock.Verify(m => m.Close(), Times.Never);
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Never);
connectionMock.Verify(m => m.Close(), Times.Never);
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Never);
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Never);
connectionMock.Verify(m => m.Close(), Times.Never);
}
}
public void Lazy_connection_is_opened_and_closed_when_necessary()
{
using (var connection = new FakeConnection(
CreateConfiguration(
e => e.ConnectionString = "Database=FrodoLives"),
new ConnectionStringResolver(null)))
{
Assert.Equal(0, connection.CreateCount);
connection.Open();
Assert.Equal(1, connection.CreateCount);
var connectionMock = Mock.Get(connection.DbConnection);
connectionMock.Verify(m => m.Open(), Times.Once);
connection.Open();
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Once);
connection.Close();
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Never);
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Once);
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Exactly(2));
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Exactly(2));
connectionMock.Verify(m => m.Close(), Times.Exactly(2));
}
}
public async Task Lazy_connection_is_async_opened_and_closed_when_necessary()
{
using (var connection = new FakeConnection(
CreateConfiguration(e => e.ConnectionString = "Database=FrodoLives"), new ConnectionStringResolver(null)))
{
Assert.Equal(0, connection.CreateCount);
var cancellationToken = new CancellationTokenSource().Token;
await connection.OpenAsync(cancellationToken);
Assert.Equal(1, connection.CreateCount);
var connectionMock = Mock.Get(connection.DbConnection);
connectionMock.Verify(m => m.OpenAsync(cancellationToken), Times.Once);
await connection.OpenAsync(cancellationToken);
await connection.OpenAsync(cancellationToken);
connectionMock.Verify(m => m.OpenAsync(It.IsAny<CancellationToken>()), Times.Once);
connection.Close();
connection.Close();
connectionMock.Verify(m => m.OpenAsync(It.IsAny<CancellationToken>()), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Never);
connection.Close();
connectionMock.Verify(m => m.OpenAsync(It.IsAny<CancellationToken>()), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Once);
await connection.OpenAsync(cancellationToken);
connectionMock.Verify(m => m.OpenAsync(cancellationToken), Times.Exactly(2));
connection.Close();
connectionMock.Verify(m => m.OpenAsync(cancellationToken), Times.Exactly(2));
connectionMock.Verify(m => m.Close(), Times.Exactly(2));
}
}
public void Lazy_connection_is_opened_and_closed_when_necessary()
{
using (var connection = new FakeConnection(
CreateConfiguration(
e => e.ConnectionString = "Database=FrodoLives"),
new ConnectionStringResolver(null)))
{
Assert.Equal(0, connection.CreateCount);
connection.Open();
Assert.Equal(1, connection.CreateCount);
var connectionMock = Mock.Get(connection.DbConnection);
connectionMock.Verify(m => m.Open(), Times.Once);
connection.Open();
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Once);
connection.Close();
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Never);
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Once);
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Exactly(2));
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Exactly(2));
connectionMock.Verify(m => m.Close(), Times.Exactly(2));
}
}
public void Lazy_connection_is_opened_and_closed_when_necessary()
{
using (var connection = new FakeConnection(
CreateOptions(new FakeOptionsExtension1 {
ConnectionString = "Database=FrodoLives"
})))
{
Assert.Equal(0, connection.CreateCount);
connection.Open();
Assert.Equal(1, connection.CreateCount);
var connectionMock = Mock.Get(connection.DbConnection);
connectionMock.Verify(m => m.Open(), Times.Once);
connection.Open();
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Once);
connection.Close();
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Never);
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Once);
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Exactly(2));
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Exactly(2));
connectionMock.Verify(m => m.Close(), Times.Exactly(2));
}
}
public async Task ReconnectDoesNotStartNewWebSocketIfDisconnectTokenTripped()
{
var fakeConnection = new FakeConnection
{
LastActiveAt = DateTime.UtcNow,
ReconnectWindow = new TimeSpan(0, 0, 15),
Url = "http://fakeserver/",
State = ConnectionState.Reconnecting
};
var fakeWebSocketTransport = new FakeWebSocketTransport();
// this is called just to initialize the disconnect token
var _ = fakeWebSocketTransport.Start(new FakeConnection(), string.Empty, new CancellationToken(true));
await fakeWebSocketTransport.Reconnect(fakeConnection, null);
Assert.Equal(0, fakeWebSocketTransport.GetInvocations("OpenWebSocket").Count());
Assert.Equal(0, fakeConnection.GetInvocations("Stop").Count());
}
public async Task InCaseOfExceptionStartInvokesOnFailureAndThrowsOriginalException()
{
var fakeConnection = new FakeConnection {
TotalTransportConnectTimeout = new TimeSpan(0, 0, 10)
};
var fakeWebSocketTransport = new FakeWebSocketTransport();
var expectedException = new Exception("OpenWebSocket failed.");
fakeWebSocketTransport.Setup <Task>("OpenWebSocket", () =>
{
throw expectedException;
});
Assert.Same(expectedException,
await Assert.ThrowsAsync <Exception>(
async() => await fakeWebSocketTransport.Start(fakeConnection, null, CancellationToken.None)));
Assert.Equal(1, fakeWebSocketTransport.GetInvocations("OnStartFailed").Count());
}
public void AutomaticResult()
{
var table = new FakeTable(new[]
{
new object[] { 1, "jonas" },
new object[] { 2, "arne" },
});
var connection = new FakeConnection();
connection.Setup(new FakeCommand(table));
var cmd = connection.CreateCommand();
cmd.CommandText = "SELECT Id, UserName FROM users";
var result = cmd.ExecuteReader();
Assert.True(result.Read());
Assert.Equal(1, (int)result[0]);
Assert.Equal("jonas", result[1]);
}
public async Task StartInvokesOnFailureAndThrowsIfOpenWebSocketCancelled()
{
var fakeConnection = new FakeConnection {
TotalTransportConnectTimeout = new TimeSpan(0, 0, 10)
};
var fakeWebSocketTransport = new FakeWebSocketTransport();
fakeWebSocketTransport.Setup <Task>("OpenWebSocket", () =>
{
var tcs = new TaskCompletionSource <object>();
tcs.SetCanceled();
return(tcs.Task);
});
Assert.Equal(
ResourceUtil.GetResource("Error_TransportFailedToConnect"),
(await Assert.ThrowsAsync <InvalidOperationException>(
async() => await fakeWebSocketTransport.Start(fakeConnection, null, CancellationToken.None))).Message);
Assert.Equal(1, fakeWebSocketTransport.GetInvocations("OnStartFailed").Count());
}
static void Main(string[] args)
{
var connection = new FakeConnection(new Uri("http://localhost:9200"));
IEnumerable <int> r = new[] { 1, 2, 3 };
int v = 2;
var context = new ElasticContext(connection);
var queryable = context
.Query <tata>("toto", "tata")
.Query(x => x
.Where(y => y.Int == 2)
.Query(y => y
.Where(z => z.String == "tutu")
)
)
.Where(y => true && y.Int == 2 || false)
.Where(y => y.Int == 2)
.Where(z => z.String == "tutu")
.Where(z => z.Array.Contains(1) || r.Contains(z.Int))
//.Where(z => z.Array.ContainsAll(r))
.Where(z => z.Array.ContainsAll(1, 2, 3))
.OrderBy(x => x.Int)
.Where(x => x.Int > 4 && x.Int > 3)
.Where(x => x.Int.Exists())
.Where(x => x.String.Missing())
.Where(x => x.Tutu.Double.Equals(42))
.Where(x => x.Tutu.Double > 2 + Settings.A + 4)
.Where(x => (x.Int < 2 || x.String == "tutu") == false)
.Where(x => x.Int.Exists() == true)
//.Where(x => bbb() == bbb())
//.Where(x => !bbb())
//.Where(x => true)
.Where(x => x.Int.Missing() == false)
.Where(x => !!!x.String.Missing())
.Skip(0)
.Take(10)
.ToList();
}
public void Lazy_connection_is_opened_and_closed_when_necessary()
{
using (var connection = new FakeConnection(
CreateOptions(new FakeOptionsExtension1 { ConnectionString = "Database=FrodoLives" })))
{
Assert.Equal(0, connection.CreateCount);
connection.Open();
Assert.Equal(1, connection.CreateCount);
var connectionMock = Mock.Get(connection.DbConnection);
connectionMock.Verify(m => m.Open(), Times.Once);
connection.Open();
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Once);
connection.Close();
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Never);
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Once);
connectionMock.Verify(m => m.Close(), Times.Once);
connection.Open();
connectionMock.Verify(m => m.Open(), Times.Exactly(2));
connection.Close();
connectionMock.Verify(m => m.Open(), Times.Exactly(2));
connectionMock.Verify(m => m.Close(), Times.Exactly(2));
}
}
public async Task ReconnectDoesNotStartNewWebSocketIfClientWasNotInConnectState()
{
var fakeConnection = new FakeConnection
{
LastActiveAt = DateTime.UtcNow,
ReconnectWindow = new TimeSpan(0, 0, 15),
Url = "http://fakeserver/"
};
fakeConnection.Setup("ChangeState",
() =>
{
fakeConnection.State = ConnectionState.Disconnected;
return(false);
});
var fakeWebSocketTransport = new FakeWebSocketTransport();
await fakeWebSocketTransport.Reconnect(fakeConnection, null);
Assert.Equal(0, fakeWebSocketTransport.GetInvocations("OpenWebSocket").Count());
Assert.Equal(0, fakeConnection.GetInvocations("Stop").Count());
}
public void ToEnumerable_without_arguments_generates_an_enumerable_without_connection_ownership()
{
var provider = Substitute.For <IMappingProvider>();
provider.Get <Tentity>().Returns(new TentityMapper());
EntityMappingProvider.Provider = provider;
var connection = new FakeConnection()
{
CurrentState = ConnectionState.Open
};
var cmd = new FakeCommand(connection, new CommandResult[] { new ReaderCommandResult()
{
Result = new FakeDataReader(new DataTable())
}, });
cmd.CommandText = "Hello";
var actual = cmd.ToEnumerable <Tentity>();
actual.GetEnumerator().Dispose();
connection.State.Should().Be(ConnectionState.Open);
}
public DbCommandTests()
{
_fakeConnection = new FakeConnection();
_db = new Db(_fakeConnection, DbConfig.Default);
}
public QueryTypedObjectTests()
{
Connection = new FakeConnection();
Connection.Open();
}
public async Task When_NMV_Found_GetAsync_Will_Retry_Until_Timeout()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.GET_WITH_NMV);
_connectionPool.AddConnection(connection);
var bucket = GetBucketForKey("key1");
var result = await bucket.GetAsync<int>("key1");
Console.WriteLine(result.Message);
Assert.IsFalse(result.Success);
Assert.AreEqual(ResponseStatus.OperationTimeout, result.Status);
}
public async Task When_Key_Does_Not_Exist_ReplaceAsync_Returns_KeyNotFound()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.REPLACE_KEYNOTFOUND);
_connectionPool.AddConnection(connection);
var key = "When_Key_Does_Not_Exist_ReplaceAsync_Returns_KeyNotFound";
var bucket = GetBucketForKey(key);
var result = await bucket.ReplaceAsync(key, "NA");
Assert.IsFalse(result.Success);
Assert.AreEqual(ResponseStatus.KeyNotFound, result.Status);
}
public async Task When_Key_Found_ReplaceAsync_Returns_Success()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.REPLACE_SUCCESS);
_connectionPool.AddConnection(connection);
var key = "When_Key_Found_ReplaceAsync_Returns_Success";
var bucket = GetBucketForKey(key);
var result = await bucket.ReplaceAsync(key, "NA");
Assert.IsTrue(result.Success);
}
public async Task When_Key_Found_InsertAsync_Returns_KeyExists()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.INSERT_KEYEXISTS);
_connectionPool.AddConnection(connection);
var key = "When_Key_Found_InsertAsync_Returns_KeyExists";
var bucket = GetBucketForKey(key);
var result = await bucket.InsertAsync(key, "NA");
Assert.IsFalse(result.Success);
Assert.AreEqual(ResponseStatus.KeyExists, result.Status);
}
public async Task When_Key_Does_Not_Exist_InsertAsync_Succeeds()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.INSERT_SUCCESS);
_connectionPool.AddConnection(connection);
var key = "When_Key_Does_Not_Exist_InsertAsync_Succeeds";
var bucket = GetBucketForKey(key);
var result = await bucket.InsertAsync(key, "NA");
Assert.IsTrue(result.Success);
Assert.AreEqual(ResponseStatus.Success, result.Status);
}
public async Task When_Key_Found_ExistAsync_Returns_True()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.OBSERVE_KEY_DNE);
_connectionPool.AddConnection(connection);
var key = "When_Key_Found_ExistAsync_Returns_True";
var bucket = GetBucketForKey(key);
var result = await bucket.ExistsAsync(key);
Assert.IsTrue(result);
}
public async Task Test_AppendAsync()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.INSERT_SUCCESS);
_connectionPool.AddConnection(connection);
var key = "Test_Append_Async";
var bucket = GetBucketForKey(key);
var result = await bucket.AppendAsync(key, "AB");
Assert.IsTrue(result.Success);
Assert.AreEqual(ResponseStatus.Success, result.Status);
}
public async Task When_Add_Fails_InsertAsync_Returns_KEY_EXISTS()
{
var connection = new FakeConnection();
connection.SetResponse(ResponsePackets.Add_FAILED_KEY_EXISTS);
_connectionPool.AddConnection(connection);
var bucket = GetBucketForKey("key1");
var result = await bucket.InsertAsync("key1", "NA");
Assert.IsFalse(result.Success);
Assert.AreEqual(ResponseStatus.KeyExists, result.Status);
}