public void OracleTest()
{
BaseKeyPair kp = BaseKeyPair.Generate();
Account oracleAccount = fluentClient.ConstructAccount(kp);
Account account = fluentClient.ConstructAccount(baseKeyPair);
ulong money = (ulong)1m.ToAettos(Unit.AE);
bool result = account.SendAmount(oracleAccount.KeyPair.PublicKey, money).WaitForFinish(TimeSpan.FromSeconds(30));
Assert.IsTrue(result);
oracleAccount.Refresh();
Assert.AreEqual(oracleAccount.Balance, money);
OracleServer <CityQuery, TemperatureResponse> query = oracleAccount.RegisterOracle <CityQuery, TemperatureResponse>().WaitForFinish(TimeSpan.FromSeconds(30));
CityTemperatureService svc = new CityTemperatureService();
svc.Server = query;
Task.Factory.StartNew(svc.Start);
OracleClient <CityQuery, TemperatureResponse> reg = account.GetOracle <CityQuery, TemperatureResponse>(query.OracleId);
TemperatureResponse resp = reg.Ask(new CityQuery {
City = "montevideo"
}).WaitForFinish(TimeSpan.FromSeconds(300));
Assert.AreEqual(resp.TemperatureCelsius, 24);
resp = reg.Ask(new CityQuery {
City = "sofia"
}).WaitForFinish(TimeSpan.FromSeconds(30));
Assert.AreEqual(resp.TemperatureCelsius, 25);
resp = reg.Ask(new CityQuery {
City = "hell"
}).WaitForFinish(TimeSpan.FromSeconds(30));
Assert.AreEqual(resp.TemperatureCelsius, 2000);
svc.Stop();
}
public void Should_get_multiple_results()
{
param.Sql = "SELECT 23 , 'name' FROM dual CONNECT BY level <= 8";
client = new OracleClient(log, param, encryption);
var results = client.Get();
Assert.That(results.Count, Is.EqualTo(8));
}
public void TestThatValidateTableThrowsDeliveryEngineMetadataExceptionIfDatatypeFromDatabaseCanNotBeMapped()
{
var fieldCollectionMock = new List <IField>(1)
{
MockRepository.GenerateMock <IField>()
};
fieldCollectionMock.ElementAt(0).Expect(m => m.NameSource)
.Return("SYSTEM_NR")
.Repeat.Any();
fieldCollectionMock.ElementAt(0).Expect(m => m.DatatypeOfSource)
.Return(typeof(string))
.Repeat.Any();
var tableMock = MockRepository.GenerateMock <ITable>();
tableMock.Expect(m => m.NameSource)
.Return("TABEL")
.Repeat.Any();
tableMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <IField>(new ObservableCollection <IField>(fieldCollectionMock)))
.Repeat.Any();
using (var oracleClient = new OracleClient())
{
Assert.Throws <DeliveryEngineMetadataException>(() => oracleClient.ValidateTable(tableMock));
oracleClient.Dispose();
}
tableMock.AssertWasCalled(m => m.Fields);
fieldCollectionMock.ElementAt(0).AssertWasCalled(m => m.DatatypeOfSource);
}
public void TestThatValidateTableThrowsDeliveryEngineMetadataExceptionIfColumnDoesNotExist()
{
var fixture = new Fixture();
var fieldCollectionMock = new List <IField>(1)
{
MockRepository.GenerateMock <IField>()
};
fieldCollectionMock.ElementAt(0).Expect(m => m.NameSource)
.Return(fixture.CreateAnonymous <string>())
.Repeat.Any();
var tableMock = MockRepository.GenerateMock <ITable>();
tableMock.Expect(m => m.NameSource)
.Return("TABEL")
.Repeat.Any();
tableMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <IField>(new ObservableCollection <IField>(fieldCollectionMock)))
.Repeat.Any();
using (var oracleClient = new OracleClient())
{
Assert.Throws <DeliveryEngineMetadataException>(() => oracleClient.ValidateTable(tableMock));
oracleClient.Dispose();
}
tableMock.AssertWasCalled(m => m.Fields);
fieldCollectionMock.ElementAt(0).AssertWasCalled(m => m.NameSource);
}
public void Should_get_multiple_results()
{
param.Sql = "SELECT 23 , 'name' FROM dual CONNECT BY level <= 8";
client = new OracleClient(log, param, encryption);
var results = client.Get();
Assert.That(results.Count, Is.EqualTo(8));
}
public void Should_get_multiple_results()
{
var param = new TaskParams("path", "SELECT 23 , 'name' FROM dual CONNECT BY level <= 8", ConnectionString, "SqlServer", "name", "statsdudp");
var log = MockRepository.GenerateMock<ILog>();
var client = new OracleClient(log, param);
var results = client.Get();
Assert.That(results.Count, Is.EqualTo(8));
}
public void TestThatConstructorInitializeOracleClient()
{
using (var oracleClient = new OracleClient())
{
Assert.That(oracleClient, Is.Not.Null);
oracleClient.Dispose();
}
}
public void TestThatValidateTableThrowsArgumentNullExceptionIfTableIsNull()
{
using (var oracleClient = new OracleClient())
{
Assert.Throws <ArgumentNullException>(() => oracleClient.ValidateTable(null));
oracleClient.Dispose();
}
}
public void TestThatDisposeCanBeCalled()
{
using (var oracleClient = new OracleClient())
{
Assert.That(oracleClient, Is.Not.Null);
oracleClient.Dispose();
}
}
public void SetUp()
{
var e = new Encryption();
param = new OracleClient { Name = "TestName", ClientName = "TestClientName", ConnectionString = "", Path = "path" };
param.ConnectionString = e.Encrypt(Cs);
log = MockRepository.GenerateMock<ILog>();
encryption = MockRepository.GenerateMock<IEncryption>();
encryption.Expect(x => x.Decrypt(e.Encrypt(Cs))).Return(Cs);
//encryption.Expect(x => x.Encrypt("abc")).Return(ConnectionString);
}
public void Should_get_result()
{
var name = Guid.NewGuid().ToString();
param.Sql = string.Format("SELECT level, '{0}', to_date('2012-FEB-03 00:00:01', 'YYYY-MON-DD HH24:MI:SS') FROM dual CONNECT BY level <= 100", name);
client = new OracleClient(log, param, encryption);
//Test
var results = client.Get();
//Asset
Assert.That(results.Count, Is.EqualTo(100));
Assert.That(results[0].Name, Is.EqualTo(name));
Assert.That(results[0].TimeStamp, Is.EqualTo(new DateTime(2012, 02, 03, 00, 00, 01)));
}
public void TestThatGetNumberOfEqualKeyValuesThrowsArgumentNullExceptionIfExtraCriteriasIsNull()
{
var fixture = new Fixture();
fixture.Customize <IKey>(e => e.FromFactory(() => MockRepository.GenerateMock <IKey>()));
using (var oracleClient = new OracleClient())
{
Assert.Throws <ArgumentNullException>(() => oracleClient.GetNumberOfEqualKeyValues(fixture.CreateAnonymous <IKey>(), null, fixture.CreateAnonymous <string>()));
oracleClient.Dispose();
}
}
public void TestThatGetNumberOfEqualKeyValuesThrowsArgumentNullExceptionIfKeyIsNull()
{
var fixture = new Fixture();
fixture.Customize <KeyValuePair <string, object> >(e => e.FromFactory(() => new KeyValuePair <string, object>(fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <object>())));
using (var oracleClient = new OracleClient())
{
Assert.Throws <ArgumentNullException>(() => oracleClient.GetNumberOfEqualKeyValues(null, fixture.CreateMany <KeyValuePair <string, object> >(5).ToList(), fixture.CreateAnonymous <string>()));
oracleClient.Dispose();
}
}
public void SetUp()
{
var e = new Encryption();
param = new OracleClient {
Name = "TestName", ClientName = "TestClientName", ConnectionString = "", Path = "path"
};
param.ConnectionString = e.Encrypt(Cs);
log = MockRepository.GenerateMock <ILog>();
encryption = MockRepository.GenerateMock <IEncryption>();
encryption.Expect(x => x.Decrypt(e.Encrypt(Cs))).Return(Cs);
//encryption.Expect(x => x.Encrypt("abc")).Return(ConnectionString);
}
public void TestThatGetNumberOfEqualKeyValuesThrowsArgumentNullExceptionIfMatchingKeyValueIsEmpty()
{
var fixture = new Fixture();
fixture.Customize <IKey>(e => e.FromFactory(() => MockRepository.GenerateMock <IKey>()));
fixture.Customize <KeyValuePair <string, object> >(e => e.FromFactory(() => new KeyValuePair <string, object>(fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <object>())));
using (var oracleClient = new OracleClient())
{
Assert.Throws <ArgumentNullException>(() => oracleClient.GetNumberOfEqualKeyValues(fixture.CreateAnonymous <IKey>(), fixture.CreateMany <KeyValuePair <string, object> >(5).ToList(), string.Empty));
oracleClient.Dispose();
}
}
public void Should_get_result()
{
var name = Guid.NewGuid().ToString();
var sql = string.Format("SELECT level, '{0}', to_date('2012-FEB-03 00:00:01', 'YYYY-MON-DD HH24:MI:SS') FROM dual CONNECT BY level <= 100", name);
var param = new TaskParams("path", sql, ConnectionString, "Oracle", name, "Statsdudp");
var log = MockRepository.GenerateMock<ILog>();
var client = new OracleClient(log, param);
//Test
var results = client.Get();
//Asset
Assert.That(results.Count, Is.EqualTo(100));
Assert.That(results[0].Name, Is.EqualTo(name));
Assert.That(results[0].TimeStamp, Is.EqualTo(new DateTime(2012, 02, 03, 00, 00, 01)));
}
public void Should_get_result_with_different_order()
{
var name = Guid.NewGuid().ToString();
param.Sql = string.Format("SELECT '{0}', to_date('2012-FEB-03 00:00:01', 'YYYY-MON-DD HH24:MI:SS'),level FROM dual CONNECT BY level <= 100", name);
client = new OracleClient(log, param, encryption);
//Test
var results = client.Get();
//Asset
Assert.That(results.Count, Is.EqualTo(100));
Assert.That(results[0].Name, Is.EqualTo(name));
Assert.That(results[0].TimeStamp, Is.EqualTo(new DateTime(2012, 02, 03, 00, 00, 01)));
}
public void Should_get_result_with_date()
{
var name = Guid.NewGuid().ToString();
param.Sql = string.Format("SELECT '{0}', to_date('2012-FEB-03 00:00:01', 'YYYY-MON-DD HH24:MI:SS') , 234 FROM dual CONNECT BY level <= 1", name);
client = new OracleClient(log, param, encryption);
//Test
var results = client.Get();
//Asset
var futureDate = DateTime.Now.Add(new TimeSpan(11, 0, 0, 0));
Assert.That(results.Count, Is.EqualTo(1));
Assert.That(results[0].Name, Is.EqualTo(name));
Assert.That(results[0].Value, Is.EqualTo(234));
Assert.That(results[0].TimeStamp, Is.EqualTo(new DateTime(2012, 02, 03, 00, 00, 01)));
}
public void Should_get_result_with_date_and_name_set_in_select()
{
var name = Guid.NewGuid().ToString();
var sql = string.Format("SELECT '{0}', to_date('2012-FEB-03 00:00:01', 'YYYY-MON-DD HH24:MI:SS') , 234 FROM dual CONNECT BY level <= 1", name);
var param = new TaskParams("path", sql, ConnectionString, "Oracle", name, "Statsdudp");
var log = MockRepository.GenerateMock<ILog>();
var client = new OracleClient(log, param);
//Test
var results = client.Get();
//Asset
Assert.That(results.Count, Is.EqualTo(1));
Assert.That(results[0].Name, Is.EqualTo(name));
Assert.That(results[0].Path, Is.EqualTo("path"));
Assert.That(results[0].Value, Is.EqualTo(234));
}
public async Task <(object result, bool done)> CheckForFinishAsync(object input, CancellationToken token = default(CancellationToken))
{
OracleClient <T, S> r = (OracleClient <T, S>)input;
OracleQuery q = await r.Account.Client.GetOracleAnswerAsync(r.Id, r.QueryId, token).ConfigureAwait(false);
if (q == null || q.Response == null || q.Response == "or_Xfbg4g==")
{
return(null, false);
}
string json = Encoding.UTF8.GetString(Utils.Encoding.DecodeCheckWithIdentifier(q.Response));
return(SophiaMapper.DeserializeOracleClass <S>(json), true);
}
public void Should_get_result_with_date_and_name_set_in_select()
{
var name = Guid.NewGuid().ToString();
param.Sql = string.Format("SELECT '{0}', to_date('2012-FEB-03 00:00:01', 'YYYY-MON-DD HH24:MI:SS') , 234 FROM dual CONNECT BY level <= 1", name);
client = new OracleClient(log, param, encryption);
//Test
var results = client.Get();
//Asset
Assert.That(results.Count, Is.EqualTo(1));
Assert.That(results[0].Name, Is.EqualTo(name));
Assert.That(results[0].Path, Is.EqualTo("path"));
Assert.That(results[0].Value, Is.EqualTo(234));
}
public void Should_get_result_with_date()
{
var name = Guid.NewGuid().ToString();
param.Sql = string.Format("SELECT '{0}', to_date('2012-FEB-03 00:00:01', 'YYYY-MON-DD HH24:MI:SS') , 234 FROM dual CONNECT BY level <= 1", name);
client = new OracleClient(log, param, encryption);
//Test
var results = client.Get();
//Asset
var futureDate = DateTime.Now.Add(new TimeSpan(11, 0, 0, 0));
Assert.That(results.Count, Is.EqualTo(1));
Assert.That(results[0].Name, Is.EqualTo(name));
Assert.That(results[0].Value, Is.EqualTo(234));
Assert.That(results[0].TimeStamp, Is.EqualTo(new DateTime(2012, 02, 03, 00, 00, 01)));
}
public void TestThatValidateTableThrowsDeliveryEngineMetadataExceptionIfTableDoesNotExist()
{
var fixture = new Fixture();
var tableMock = MockRepository.GenerateMock <ITable>();
tableMock.Expect(m => m.NameSource)
.Return(fixture.CreateAnonymous <string>())
.Repeat.Any();
using (var oracleClient = new OracleClient())
{
Assert.Throws <DeliveryEngineMetadataException>(() => oracleClient.ValidateTable(tableMock));
oracleClient.Dispose();
}
tableMock.AssertWasCalled(m => m.NameSource);
}
public void TestThatGetDataThrowsArgumentNullExceptionIfTableIsNull()
{
var fixture = new Fixture();
fixture.Customize <IHandleDataEventArgs>(e => e.FromFactory(() => MockRepository.GenerateMock <IHandleDataEventArgs>()));
DeliveryEngineEventHandler <IHandleDataEventArgs> onHandleOracleData = (s, e) =>
{
Assert.That(s, Is.Not.Null);
Assert.That(e, Is.Not.Null);
};
onHandleOracleData.Invoke(fixture.CreateAnonymous <object>(), fixture.CreateAnonymous <IHandleDataEventArgs>());
using (var oracleClient = new OracleClient())
{
Assert.Throws <ArgumentNullException>(() => oracleClient.GetData(null, onHandleOracleData));
oracleClient.Dispose();
}
}
public void TestThatGetDataThrowsArgumentNullExceptionIfOnHandleOracleDataIsNull()
{
var fixture = new Fixture();
fixture.Customize <ITable>(e => e.FromFactory(() => MockRepository.GenerateMock <ITable>()));
var tableMock = fixture.CreateAnonymous <ITable>();
using (var oracleClient = new OracleClient())
{
Assert.Throws <ArgumentNullException>(() => oracleClient.GetData(tableMock, null));
oracleClient.Dispose();
}
tableMock.AssertWasNotCalled(m => m.Fields);
tableMock.AssertWasNotCalled(m => m.RecordFilters);
tableMock.AssertWasNotCalled(m => m.PrimaryKey);
tableMock.AssertWasNotCalled(m => m.NameSource);
}
public void TestThatGetNumberOfEqualKeyValuesThrowsDeliveryEngineMetadataExceptionIfTableIsNullOnKey()
{
var fixture = new Fixture();
fixture.Customize <KeyValuePair <string, object> >(e => e.FromFactory(() => new KeyValuePair <string, object>(fixture.CreateAnonymous <string>(), fixture.CreateAnonymous <object>())));
var keyMock = MockRepository.GenerateMock <IKey>();
keyMock.Expect(m => m.Table)
.Return(null)
.Repeat.Any();
using (var oracleClient = new OracleClient())
{
Assert.Throws <DeliveryEngineMetadataException>(() => oracleClient.GetNumberOfEqualKeyValues(keyMock, fixture.CreateMany <KeyValuePair <string, object> >(5).ToList(), fixture.CreateAnonymous <string>()));
oracleClient.Dispose();
}
keyMock.AssertWasCalled(m => m.Table);
}
public void TestThatSelectCountForTableGetNumberOfRecordsWithoutRecordFilters()
{
var tableMock = MockRepository.GenerateMock <ITable>();
tableMock.Expect(m => m.NameSource)
.Return("TABEL")
.Repeat.Any();
tableMock.Expect(m => m.RecordFilters)
.Return(new ReadOnlyObservableCollection <IFilter>(new ObservableCollection <IFilter>(new List <IFilter>(0))))
.Repeat.Any();
using (var oracleClient = new OracleClient())
{
var numberOfRecords = oracleClient.SelectCountForTable(tableMock);
Assert.That(numberOfRecords, Is.GreaterThan(0));
oracleClient.Dispose();
}
tableMock.AssertWasCalled(m => m.NameSource);
tableMock.AssertWasCalled(m => m.RecordFilters);
}
public void TestThatSelectCountForTableGetNumberOfRecordsWithRecordFilters()
{
var firstFilter = MockRepository.GenerateMock <IFilter>();
firstFilter.Expect(m => m.AsSql())
.Return("SYSTEM_NR=0 AND TABEL=0 AND NR='00'")
.Repeat.Any();
var secordFilter = MockRepository.GenerateMock <IFilter>();
secordFilter.Expect(m => m.AsSql())
.Return("SYSTEM_NR=0 AND TABEL=0 AND NR='01'")
.Repeat.Any();
var tableMock = MockRepository.GenerateMock <ITable>();
tableMock.Expect(m => m.NameSource)
.Return("TABEL")
.Repeat.Any();
tableMock.Expect(m => m.RecordFilters)
.Return(new ReadOnlyObservableCollection <IFilter>(new ObservableCollection <IFilter>(new List <IFilter> {
firstFilter, secordFilter
})))
.Repeat.Any();
using (var oracleClient = new OracleClient())
{
var numberOfRecords = oracleClient.SelectCountForTable(tableMock);
Assert.That(numberOfRecords, Is.EqualTo(2));
oracleClient.Dispose();
}
tableMock.AssertWasCalled(m => m.NameSource);
tableMock.AssertWasCalled(m => m.RecordFilters);
firstFilter.AssertWasCalled(m => m.AsSql());
secordFilter.AssertWasCalled(m => m.AsSql());
}
static void Main(string[] args)
{
OracleClient Db = new OracleClient("SRTEST2", "ISCARDUSER", "Gbr18k6P");
//OracleClient Db = new OracleClient("sbdp-center-o07.bank.lan", "1521", "srtest2", "ISCARDUSER", "Gbr18k6P");
OracleConnection conn = Db.OpenConection();
Console.WriteLine("State: {0}", conn.State);
ArrayList param = new ArrayList();
param.Add(new AddParametrs("I_ID", 5244, OracleType.Int32, ParameterDirection.Input));
param.Add(new AddParametrs("I_REF_ROLE", 3724, OracleType.Int32, ParameterDirection.Input));
//OracleCommand cmd = new OracleCommand();
//cmd.Connection = conn;
//cmd.CommandText = strSql;
//cmd.CommandType = CommandType.Text;
//OracleParameterCollection prm = cmd.Parameters;
//Db.AddParameter("I_ID", 5244, OracleType.Int32, prm);
//Db.AddParameter("I_REF_ROLE", 3724, OracleType.Int32, prm);
//cmd.Prepare();
//OracleDataReader dr = cmd.ExecuteReader();
string strSql = "select t.* from SR_BANK.SR_USER t where t.ID =:I_ID and t.REF_ROLE =:I_REF_ROLE";
//string strSql = "select t.* from SR_BANK.SR_USER t";
OracleDataReader dr = Db.OracleExecuteQuery(strSql, param);
while (dr.Read())
{
Console.Write("{0}\t{1} \n", dr[0], dr[1]);
}
dr.Close();
Db.CloseConnection();
Console.WriteLine("State: {0}", conn.State);
}
public static InProgress <S> Ask <T, S>(this OracleClient <T, S> oracle, T query, ulong fee = Constants.BaseConstants.ORACLE_QUERY_FEE, TTLType queryTtlType = TTLType.Delta, ulong queryTtl = Constants.BaseConstants.ORACLE_QUERY_TTL_VALUE, ulong responseRelativeTtl = Constants.BaseConstants.ORACLE_RESPONSE_TTL_VALUE) => oracle.AskAsync(query, fee, queryTtlType, queryTtl, responseRelativeTtl).RunAndUnwrap();
public void Should_get_result_with_date_and_name_set_in_select()
{
var name = Guid.NewGuid().ToString();
param.Sql = string.Format("SELECT '{0}', to_date('2012-FEB-03 00:00:01', 'YYYY-MON-DD HH24:MI:SS') , 234 FROM dual CONNECT BY level <= 1", name);
client = new OracleClient(log, param, encryption);
//Test
var results = client.Get();
//Asset
Assert.That(results.Count, Is.EqualTo(1));
Assert.That(results[0].Name, Is.EqualTo(name));
Assert.That(results[0].Path, Is.EqualTo("path"));
Assert.That(results[0].Value, Is.EqualTo(234));
}
public void TestThatGetDataGetDataWithRecordFilters()
{
var fieldCollectionMock = new List <IField>(7)
{
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>()
};
fieldCollectionMock.ElementAt(0).Expect(m => m.NameSource)
.Return("SYSTEM_NR")
.Repeat.Any();
fieldCollectionMock.ElementAt(0).Expect(m => m.DatatypeOfSource)
.Return(typeof(int?))
.Repeat.Any();
fieldCollectionMock.ElementAt(0).Expect(m => m.DatatypeOfTarget)
.Return(typeof(int?))
.Repeat.Any();
fieldCollectionMock.ElementAt(0).Expect(m => m.Nullable)
.Return(false)
.Repeat.Any();
fieldCollectionMock.ElementAt(1).Expect(m => m.NameSource)
.Return("TABEL")
.Repeat.Any();
fieldCollectionMock.ElementAt(1).Expect(m => m.DatatypeOfSource)
.Return(typeof(int?))
.Repeat.Any();
fieldCollectionMock.ElementAt(1).Expect(m => m.DatatypeOfTarget)
.Return(typeof(int?))
.Repeat.Any();
fieldCollectionMock.ElementAt(1).Expect(m => m.Nullable)
.Return(false)
.Repeat.Any();
fieldCollectionMock.ElementAt(2).Expect(m => m.NameSource)
.Return("NR")
.Repeat.Any();
fieldCollectionMock.ElementAt(2).Expect(m => m.DatatypeOfSource)
.Return(typeof(string))
.Repeat.Any();
fieldCollectionMock.ElementAt(2).Expect(m => m.DatatypeOfTarget)
.Return(typeof(string))
.Repeat.Any();
fieldCollectionMock.ElementAt(2).Expect(m => m.Nullable)
.Return(false)
.Repeat.Any();
fieldCollectionMock.ElementAt(3).Expect(m => m.NameSource)
.Return("TEKST")
.Repeat.Any();
fieldCollectionMock.ElementAt(3).Expect(m => m.DatatypeOfSource)
.Return(typeof(string))
.Repeat.Any();
fieldCollectionMock.ElementAt(3).Expect(m => m.DatatypeOfTarget)
.Return(typeof(string))
.Repeat.Any();
fieldCollectionMock.ElementAt(3).Expect(m => m.Nullable)
.Return(true)
.Repeat.Any();
fieldCollectionMock.ElementAt(4).Expect(m => m.NameSource)
.Return("FORDELPCT")
.Repeat.Any();
fieldCollectionMock.ElementAt(4).Expect(m => m.DatatypeOfSource)
.Return(typeof(decimal?))
.Repeat.Any();
fieldCollectionMock.ElementAt(4).Expect(m => m.DatatypeOfTarget)
.Return(typeof(decimal?))
.Repeat.Any();
fieldCollectionMock.ElementAt(4).Expect(m => m.Nullable)
.Return(true)
.Repeat.Any();
fieldCollectionMock.ElementAt(5).Expect(m => m.NameSource)
.Return("O_DATO")
.Repeat.Any();
fieldCollectionMock.ElementAt(5).Expect(m => m.DatatypeOfSource)
.Return(typeof(DateTime?))
.Repeat.Any();
fieldCollectionMock.ElementAt(5).Expect(m => m.DatatypeOfTarget)
.Return(typeof(DateTime?))
.Repeat.Any();
fieldCollectionMock.ElementAt(5).Expect(m => m.Nullable)
.Return(true)
.Repeat.Any();
fieldCollectionMock.ElementAt(6).Expect(m => m.NameSource)
.Return("O_TID")
.Repeat.Any();
fieldCollectionMock.ElementAt(6).Expect(m => m.DatatypeOfSource)
.Return(typeof(TimeSpan?))
.Repeat.Any();
fieldCollectionMock.ElementAt(6).Expect(m => m.DatatypeOfTarget)
.Return(typeof(TimeSpan?))
.Repeat.Any();
fieldCollectionMock.ElementAt(6).Expect(m => m.Nullable)
.Return(true)
.Repeat.Any();
var primaryKeyMock = MockRepository.GenerateMock <ICandidateKey>();
primaryKeyMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <KeyValuePair <IField, IMap> >(new ObservableCollection <KeyValuePair <IField, IMap> >(fieldCollectionMock.GetRange(0, 3).Select(field => new KeyValuePair <IField, IMap>(field, null)))))
.Repeat.Any();
var recordFilterCollectionMock = new List <IFilter>(2)
{
MockRepository.GenerateMock <IFilter>(),
MockRepository.GenerateMock <IFilter>()
};
recordFilterCollectionMock.ElementAt(0).Expect(m => m.AsSql())
.Return("TABEL=0")
.Repeat.Any();
recordFilterCollectionMock.ElementAt(1).Expect(m => m.AsSql())
.Return("TABEL=1")
.Repeat.Any();
var tableMock = MockRepository.GenerateMock <ITable>();
tableMock.Expect(m => m.NameSource)
.Return("TABEL")
.Repeat.Any();
tableMock.Expect(m => m.PrimaryKey)
.Return(primaryKeyMock)
.Repeat.Any();
tableMock.Expect(m => m.RecordFilters)
.Return(new ReadOnlyObservableCollection <IFilter>(new ObservableCollection <IFilter>(recordFilterCollectionMock)))
.Repeat.Any();
tableMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <IField>(new ObservableCollection <IField>(fieldCollectionMock)))
.Repeat.Any();
using (var oracleClient = new OracleClient())
{
var data = new List <IEnumerable <IDataObjectBase> >();
oracleClient.GetData(tableMock, (s, e) =>
{
data.AddRange(e.Data);
Assert.That(data.Any(row =>
{
var dataRow = row.ToList();
return(dataRow.ElementAt(1).GetSourceValue <int?>() == 0 &&
dataRow.ElementAt(1).GetSourceValue <int?>() == 1);
}), Is.False);
});
Assert.That(data, Is.Not.Null);
var dataAsList = data.ToList();
Assert.That(dataAsList, Is.Not.Null);
Assert.That(dataAsList.Count(), Is.GreaterThan(0));
oracleClient.Dispose();
}
tableMock.AssertWasCalled(m => m.Fields);
tableMock.AssertWasCalled(m => m.RecordFilters);
tableMock.AssertWasCalled(m => m.PrimaryKey);
tableMock.AssertWasCalled(m => m.NameSource);
recordFilterCollectionMock.ElementAt(0).AssertWasCalled(m => m.AsSql());
recordFilterCollectionMock.ElementAt(1).AssertWasCalled(m => m.AsSql());
primaryKeyMock.AssertWasCalled(m => m.Fields);
}
public void TestThatGetNumberOfEqualKeyValuesGetsNumberOfEqualKeyValuesForKeyWhereThereMultipleRecords()
{
var fieldCollection = new List <IField>
{
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>()
};
fieldCollection.ElementAt(0).Expect(m => m.NameSource)
.Return("SYSTEM_NR")
.Repeat.Any();
fieldCollection.ElementAt(0).Expect(m => m.DatatypeOfSource)
.Return(typeof(int?))
.Repeat.Any();
fieldCollection.ElementAt(0).Expect(m => m.DatatypeOfTarget)
.Return(typeof(int?))
.Repeat.Any();
fieldCollection.ElementAt(1).Expect(m => m.NameSource)
.Return("TABEL")
.Repeat.Any();
fieldCollection.ElementAt(1).Expect(m => m.DatatypeOfSource)
.Return(typeof(int?))
.Repeat.Any();
fieldCollection.ElementAt(1).Expect(m => m.DatatypeOfTarget)
.Return(typeof(int?))
.Repeat.Any();
fieldCollection.ElementAt(2).Expect(m => m.NameSource)
.Return("NR")
.Repeat.Any();
fieldCollection.ElementAt(2).Expect(m => m.DatatypeOfSource)
.Return(typeof(string))
.Repeat.Any();
fieldCollection.ElementAt(2).Expect(m => m.DatatypeOfTarget)
.Return(typeof(string))
.Repeat.Any();
fieldCollection.ElementAt(3).Expect(m => m.NameSource)
.Return("TEKST")
.Repeat.Any();
fieldCollection.ElementAt(3).Expect(m => m.DatatypeOfSource)
.Return(typeof(string))
.Repeat.Any();
fieldCollection.ElementAt(3).Expect(m => m.DatatypeOfTarget)
.Return(typeof(string))
.Repeat.Any();
var filterCollection = new List <IFilter>();
var tableMock = MockRepository.GenerateMock <ITable>();
var keyMock = MockRepository.GenerateMock <ICandidateKey>();
keyMock.Expect(m => m.Table)
.Return(tableMock)
.Repeat.Any();
keyMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <KeyValuePair <IField, IMap> >(new ObservableCollection <KeyValuePair <IField, IMap> >(new List <KeyValuePair <IField, IMap> >(fieldCollection.GetRange(0, 3).Select(field => new KeyValuePair <IField, IMap>(field, null))))))
.Repeat.Any();
tableMock.Expect(m => m.NameSource)
.Return("TABEL")
.Repeat.Any();
tableMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <IField>(new ObservableCollection <IField>(fieldCollection)))
.Repeat.Any();
tableMock.Expect(m => m.PrimaryKey)
.Return(keyMock)
.Repeat.Any();
tableMock.Expect(m => m.RecordFilters)
.WhenCalled(e => e.ReturnValue = new ReadOnlyObservableCollection <IFilter>(new ObservableCollection <IFilter>(filterCollection)))
.Return(new ReadOnlyObservableCollection <IFilter>(new ObservableCollection <IFilter>(filterCollection)))
.Repeat.Any();
tableMock.Expect(m => m.AddRecordFilter(Arg <IFilter> .Is.NotNull))
.WhenCalled(e => filterCollection.Add((IFilter)e.Arguments.ElementAt(0)))
.Repeat.Any();
tableMock.Expect(m => m.Clone())
.Return(tableMock)
.Repeat.Any();
var mocker = new MockRepository();
var dataManipulatorsMock = mocker.DynamicMultiMock <IDataManipulators>(new[] { typeof(IEnumerable <IDataManipulator>) });
Expect.Call(dataManipulatorsMock.GetEnumerator())
.Return(new List <IDataManipulator>(0).GetEnumerator())
.Repeat.Any();
mocker.ReplayAll();
using (var oracleClient = new OracleClient(dataManipulatorsMock))
{
var extraCriterias = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>("SYSTEM_NR", 0),
new KeyValuePair <string, object>("TABEL", 0)
};
var numberOfEqualKeys = oracleClient.GetNumberOfEqualKeyValues(keyMock, extraCriterias, "0|0|00");
Assert.That(numberOfEqualKeys, Is.EqualTo(1));
oracleClient.Dispose();
}
keyMock.AssertWasCalled(m => m.Table);
tableMock.AssertWasCalled(m => m.Clone());
tableMock.AssertWasCalled(m => m.RecordFilters, opt => opt.Repeat.Times(6));
tableMock.AssertWasCalled(m => m.AddRecordFilter(Arg <IFilter> .Is.NotNull));
dataManipulatorsMock.AssertWasCalled(m => m.GetEnumerator());
}
public void TestThatValidateTableValidatesTable()
{
var fieldCollectionMock = new List <IField>(7)
{
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>()
};
fieldCollectionMock.ElementAt(0).Expect(m => m.NameSource)
.Return("SYSTEM_NR")
.Repeat.Any();
fieldCollectionMock.ElementAt(0).Expect(m => m.DatatypeOfSource)
.Return(typeof(int?))
.Repeat.Any();
fieldCollectionMock.ElementAt(1).Expect(m => m.NameSource)
.Return("TABEL")
.Repeat.Any();
fieldCollectionMock.ElementAt(1).Expect(m => m.DatatypeOfSource)
.Return(typeof(int?))
.Repeat.Any();
fieldCollectionMock.ElementAt(2).Expect(m => m.NameSource)
.Return("NR")
.Repeat.Any();
fieldCollectionMock.ElementAt(2).Expect(m => m.DatatypeOfSource)
.Return(typeof(string))
.Repeat.Any();
fieldCollectionMock.ElementAt(3).Expect(m => m.NameSource)
.Return("TEKST")
.Repeat.Any();
fieldCollectionMock.ElementAt(3).Expect(m => m.DatatypeOfSource)
.Return(typeof(string))
.Repeat.Any();
fieldCollectionMock.ElementAt(4).Expect(m => m.NameSource)
.Return("FORDELPCT")
.Repeat.Any();
fieldCollectionMock.ElementAt(4).Expect(m => m.DatatypeOfSource)
.Return(typeof(decimal?))
.Repeat.Any();
fieldCollectionMock.ElementAt(5).Expect(m => m.NameSource)
.Return("O_DATO")
.Repeat.Any();
fieldCollectionMock.ElementAt(5).Expect(m => m.DatatypeOfSource)
.Return(typeof(DateTime?))
.Repeat.Any();
fieldCollectionMock.ElementAt(6).Expect(m => m.NameSource)
.Return("O_TID")
.Repeat.Any();
fieldCollectionMock.ElementAt(6).Expect(m => m.DatatypeOfSource)
.Return(typeof(TimeSpan?))
.Repeat.Any();
var tableMock = MockRepository.GenerateMock <ITable>();
tableMock.Expect(m => m.NameSource)
.Return("TABEL")
.Repeat.Any();
tableMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <IField>(new ObservableCollection <IField>(fieldCollectionMock)))
.Repeat.Any();
using (var oracleClient = new OracleClient())
{
oracleClient.ValidateTable(tableMock);
oracleClient.Dispose();
}
tableMock.AssertWasCalled(m => m.NameSource);
tableMock.AssertWasCalled(m => m.Fields);
fieldCollectionMock.ElementAt(0).AssertWasCalled(m => m.NameSource);
fieldCollectionMock.ElementAt(0).AssertWasCalled(m => m.DatatypeOfSource);
fieldCollectionMock.ElementAt(1).AssertWasCalled(m => m.NameSource);
fieldCollectionMock.ElementAt(1).AssertWasCalled(m => m.DatatypeOfSource);
fieldCollectionMock.ElementAt(2).AssertWasCalled(m => m.NameSource);
fieldCollectionMock.ElementAt(2).AssertWasCalled(m => m.DatatypeOfSource);
fieldCollectionMock.ElementAt(3).AssertWasCalled(m => m.NameSource);
fieldCollectionMock.ElementAt(3).AssertWasCalled(m => m.DatatypeOfSource);
}
public void TestThatGetNumberOfEqualKeyValuesGetsNumberOfEqualKeyValuesForKeyWhereThereOnlyAreOnRecord()
{
var fixture = new Fixture();
var fieldCollection = new List <IField>
{
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>(),
MockRepository.GenerateMock <IField>()
};
fieldCollection.ElementAt(0).Expect(m => m.NameSource)
.Return("SYSTEM_NR")
.Repeat.Any();
fieldCollection.ElementAt(0).Expect(m => m.DatatypeOfSource)
.Return(typeof(int?))
.Repeat.Any();
fieldCollection.ElementAt(1).Expect(m => m.NameSource)
.Return("TABEL")
.Repeat.Any();
fieldCollection.ElementAt(1).Expect(m => m.DatatypeOfSource)
.Return(typeof(int?))
.Repeat.Any();
fieldCollection.ElementAt(2).Expect(m => m.NameSource)
.Return("NR")
.Repeat.Any();
fieldCollection.ElementAt(2).Expect(m => m.DatatypeOfSource)
.Return(typeof(string))
.Repeat.Any();
fieldCollection.ElementAt(3).Expect(m => m.NameSource)
.Return("TEKST")
.Repeat.Any();
fieldCollection.ElementAt(3).Expect(m => m.DatatypeOfSource)
.Return(typeof(string))
.Repeat.Any();
var filterCollection = new List <IFilter>();
var tableMock = MockRepository.GenerateMock <ITable>();
var keyMock = MockRepository.GenerateMock <ICandidateKey>();
keyMock.Expect(m => m.Table)
.Return(tableMock)
.Repeat.Any();
keyMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <KeyValuePair <IField, IMap> >(new ObservableCollection <KeyValuePair <IField, IMap> >(fieldCollection.GetRange(0, 3).Select(field => new KeyValuePair <IField, IMap>(field, null)))))
.Repeat.Any();
tableMock.Expect(m => m.NameSource)
.Return("TABEL")
.Repeat.Any();
tableMock.Expect(m => m.Fields)
.Return(new ReadOnlyObservableCollection <IField>(new ObservableCollection <IField>(fieldCollection)))
.Repeat.Any();
tableMock.Expect(m => m.PrimaryKey)
.Return(keyMock)
.Repeat.Any();
tableMock.Expect(m => m.RecordFilters)
.WhenCalled(e => e.ReturnValue = new ReadOnlyObservableCollection <IFilter>(new ObservableCollection <IFilter>(filterCollection)))
.Return(new ReadOnlyObservableCollection <IFilter>(new ObservableCollection <IFilter>(filterCollection)))
.Repeat.Any();
tableMock.Expect(m => m.AddRecordFilter(Arg <IFilter> .Is.NotNull))
.WhenCalled(e => filterCollection.Add((IFilter)e.Arguments.ElementAt(0)))
.Repeat.Any();
tableMock.Expect(m => m.Clone())
.Return(tableMock)
.Repeat.Any();
using (var oracleClient = new OracleClient())
{
var extraCriterias = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>("SYSTEM_NR", 0),
new KeyValuePair <string, object>("TABEL", 0),
new KeyValuePair <string, object>("NR", "00")
};
var numberOfEqualKeys = oracleClient.GetNumberOfEqualKeyValues(keyMock, extraCriterias, fixture.CreateAnonymous <string>());
Assert.That(numberOfEqualKeys, Is.EqualTo(1));
oracleClient.Dispose();
}
keyMock.AssertWasCalled(m => m.Table);
tableMock.AssertWasCalled(m => m.Clone());
tableMock.AssertWasCalled(m => m.RecordFilters, opt => opt.Repeat.Times(7));
tableMock.AssertWasCalled(m => m.AddRecordFilter(Arg <IFilter> .Is.NotNull));
}
