public ContextEntityTypesProvider(IMetadataProvider metadataProvider)
{
var testMetadata = metadataProvider.GetMetadataSet<TestCaseMetadataIdentity>().Metadata.Values.OfType<TestCaseMetadataElement>().ToArray();
var features = GetContextFeatures(testMetadata);
_entitiesByContext = features.GroupBy(x => x.Context, x => x.Data)
.ToDictionary(x => x.Key, x => x.SelectMany(y => y).Select(y => y.GetType()).Distinct().ToArray());
}
protected CommandContextBase(Command command, BuilderContext builderContext)
{
CurrentCommand = command;
BuildParameters = builderContext.Parameters;
ResultEntry = new CommandResultEntry();
MetadataProvider = builderContext.MetadataProvider;
}
public UpdateMetadataCommandTests()
{
_metadataProvider = Substitute.For<IMetadataProvider>();
_progressManager = Substitute.For<IProgressManagerViewModel>();
_busyProvider = Substitute.For<IBusyProvider>();
_command = new UpdateMetadataCommand(_metadataProvider, _progressManager, _busyProvider);
}
SetRandomMetadata
(
IMetadataProvider oMetadataProvider,
Boolean bSetMetadataValues,
Boolean bSetTag,
Int32 iSeed
)
{
KeyValuePair<String, Object> [] aoRandomMetadata;
Object oRandomTag;
GetRandomMetadata(iSeed, out aoRandomMetadata, out oRandomTag);
if (bSetMetadataValues)
{
foreach (KeyValuePair<String, Object> oRandomMetadata
in aoRandomMetadata)
{
oMetadataProvider.SetValue(
oRandomMetadata.Key, oRandomMetadata.Value);
}
}
if (bSetTag)
{
oMetadataProvider.Tag = oRandomTag;
}
}
/// <summary>
/// Loads the signature.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="token">The token.</param>
public void LoadSignature(IMetadataProvider provider, TokenTypes token)
{
byte[] buffer;
int index = 0;
provider.Read(token, out buffer);
ParseSignature(buffer, ref index);
Debug.Assert(index == buffer.Length, @"Signature parser didn't complete.");
}
public EdmModelBuilder(IMetadataProvider metadataProvider)
{
if (metadataProvider == null)
{
throw new ArgumentNullException("metadataProvider");
}
_metadataProvider = metadataProvider;
}
public PdbWriter(string fileName, IMetadataProvider metadataProvider)
{
this.pdb = new ISymUnmanagedWriter2();
this.metadataProvider = metadataProvider;
this.documentWriters = new Dictionary<string, ISymUnmanagedDocumentWriter>();
this.pdb.Initialize(new Metadata(metadataProvider), fileName, pIStream: null, fFullBuild: true);
}
protected TestBase(ITestFixture fixture)
{
this.dte = fixture.Dte;
this.metadataProvider = fixture.Provider;
this.isRoslyn = fixture is RoslynFixture;
this.isCodeDom = fixture is CodeDomFixture;
}
/// <summary>
/// Loads the signature.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="token">The token.</param>
public Signature(IMetadataProvider provider, TokenTypes token)
{
SignatureReader reader = new SignatureReader(provider.ReadBlob(token));
this.ParseSignature(reader);
Debug.Assert(reader.Index == reader.Length, @"Signature parser didn't complete.");
this.token = token;
}
public EventBus(IMessageSender messageSender,
IRoutingKeyProvider routingKeyProvider,
IMetadataProvider metadataProvider)
{
this.messageSender = messageSender;
this.routingKeyProvider = routingKeyProvider;
this.metadataProvider = metadataProvider;
this.logger = LogManager.GetLogger("ThinkNet");
}
private static IEdmModel BuildModel(IMetadataProvider provider, Uri contextId)
{
var builder = new EdmModelBuilder(provider);
var model = builder.Build(contextId);
model.Dump();
return model;
}
/// <summary>
/// Parses the specified provider.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="token">The token.</param>
/// <returns></returns>
public static LocalVariableSignature Parse(IMetadataProvider provider, TokenTypes token)
{
byte[] buffer;
int index = 0;
provider.Read(token, out buffer);
LocalVariableSignature sig = new LocalVariableSignature();
sig.ParseSignature(buffer, ref index);
Debug.Assert(index == buffer.Length, @"Signature parser didn't complete.");
return sig;
}
public void OnSetup()
{
var customizedMetadataDto = CreateCustomizedMetadataDto ();
_metadataProvider = new PatientProfileDto { MetadataDto = customizedMetadataDto };
var defaultMetadataDto = CreateDefaultMetadataDto ();
var metadataServiceMock = new Mock<IMetadataService> ();
metadataServiceMock.Setup ( x => x.GetMetadata ( It.IsAny<Type> () ) ).Returns ( defaultMetadataDto );
_metadataService = metadataServiceMock.Object;
}
private static DbModel BuildModel(IMetadataProvider metadataProvider, IClrTypeProvider clrTypeProvider)
{
BoundedContextElement context;
metadataProvider.TryGetMetadata(BuildContextId(), out context);
var configurator = new DbModelBuilderConfigurator(metadataProvider, clrTypeProvider);
var builder = configurator.Configure(context);
return(builder.Build(EffortProvider));
}
public GenerationController(DTE dte, IMetadataProvider metadataProvider, SolutionMonitor solutionMonitor, TemplateController templateController, EventQueue eventQueue)
{
this.dte = dte;
this.metadataProvider = metadataProvider;
this.templateController = templateController;
solutionMonitor.FileAdded += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Render, args.Path);
solutionMonitor.FileChanged += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Render, args.Path);
solutionMonitor.FileDeleted += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Delete, args.Path);
solutionMonitor.FileRenamed += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Rename, args.OldPath, args.NewPath);
}
private int GetDefaultOrder(IMetadataProvider provider)
{
var hasOrder = provider as IHasOrder;
if (hasOrder != null)
{
return(hasOrder.Order);
}
return(0);
}
public GenerationController(DTE dte, IMetadataProvider metadataProvider, SolutionMonitor solutionMonitor, TemplateController templateController, EventQueue eventQueue)
{
this.dte = dte;
this.metadataProvider = metadataProvider;
this.templateController = templateController;
solutionMonitor.FileAdded += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Render, args.Path);
solutionMonitor.FileChanged += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Render, args.Path);
solutionMonitor.FileDeleted += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Delete, args.Path);
solutionMonitor.FileRenamed += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Rename, args.OldPath, args.NewPath);
}
private static TreeNode CreateDatabaseNode(IMetadataProvider provider, ConnectionInfo connection)
{
TreeNode node = new TreeNodeWithConnectionInfo(provider.Name, connection);
node.SelectedImageKey = "Database";
node.ImageKey = "Database";
node.Tag = provider;
node.Name = node.Text;
return(node);
}
public OperationsPrimaryProcessingJob(
IMetadataProvider metadataProvider,
IMessageFlowProcessorFactory messageFlowProcessorFactory,
ISignInService signInService,
IUserImpersonationService userImpersonationService,
ITracer tracer)
: base(signInService, userImpersonationService, tracer)
{
_metadataProvider = metadataProvider;
_messageFlowProcessorFactory = messageFlowProcessorFactory;
}
public CommandBus(IMessageSender messageSender,
ICommandResultManager commandResultManager,
IRoutingKeyProvider routingKeyProvider,
IMetadataProvider metadataProvider)
{
this.messageSender = messageSender;
this.commandResultManager = commandResultManager;
this.routingKeyProvider = routingKeyProvider;
this.metadataProvider = metadataProvider;
this.logger = LogManager.GetLogger("ThinkNet");
}
/// <summary>
/// Writes the assembly processor table.
/// </summary>
/// <param name="metadataSource">The metadata source.</param>
/// <param name="metadataWriter">The metadata writer.</param>
private static void WriteAssemblyProcessorTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter)
{
AssemblyProcessorRow row;
WriteTable(TokenTypes.AssemblyProcessor, metadataSource, token =>
{
metadataSource.Read(token, out row);
metadataWriter.Write(row.Processor);
});
}
public OperationsPrimaryProcessingJob(
IMetadataProvider metadataProvider,
IMessageFlowProcessorFactory messageFlowProcessorFactory,
ISignInService signInService,
IUserImpersonationService userImpersonationService,
ITracer tracer)
: base(signInService, userImpersonationService, tracer)
{
_metadataProvider = metadataProvider;
_messageFlowProcessorFactory = messageFlowProcessorFactory;
}
/// <summary>
/// Writes the module ref table.
/// </summary>
/// <param name="metadataSource">The metadata source.</param>
/// <param name="metadataWriter">The metadata writer.</param>
private static void WriteModuleRefTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter)
{
ModuleRefRow row;
WriteTable(TokenTypes.ModuleRef, metadataSource, token =>
{
metadataSource.Read(token, out row);
metadataWriter.Write(row.NameStringIdx);
});
}
/// <summary>
/// Loads the signature.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="token">The token.</param>
public void LoadSignature(ISignatureContext context, IMetadataProvider provider, TokenTypes token)
{
byte[] buffer;
provider.Read(token, out buffer);
int index = 0;
this.ParseSignature(context, buffer, ref index);
Debug.Assert(index == buffer.Length, @"Signature parser didn't complete.");
this.token = token;
}
/// <summary>
/// Writes the type spec table.
/// </summary>
/// <param name="metadataSource">The metadata source.</param>
/// <param name="metadataWriter">The metadata writer.</param>
private static void WriteTypeSpecTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter)
{
TypeSpecRow row;
WriteTable(TokenTypes.TypeSpec, metadataSource, token =>
{
metadataSource.Read(token, out row);
metadataWriter.Write(row.SignatureBlobIdx);
});
}
/// <summary>
/// Writes the standalone sig table.
/// </summary>
/// <param name="metadataSource">The metadata source.</param>
/// <param name="metadataWriter">The metadata writer.</param>
private static void WriteStandaloneSigTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter)
{
StandAloneSigRow row;
WriteTable(TokenTypes.StandAloneSig, metadataSource, token =>
{
metadataSource.Read(token, out row);
metadataWriter.Write(row.SignatureBlobIdx);
});
}
public CachedEntityReader(
IMetadataProvider metadataProvider,
IDatabase database,
ICacheProvider cacheProvider)
: base(metadataProvider, database)
{
cacheProvider.ThrowIfNull();
Cache = cacheProvider;
_keyGenerator = new CacheKeyGenerator <TEntity>();
}
/// <summary>
/// Parses the specified provider.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="token">The token.</param>
/// <returns></returns>
public static MethodSignature Parse(IMetadataProvider provider, TokenTypes token)
{
byte[] buffer;
int index = 0;
provider.Read(token, out buffer);
MethodSignature msig = new MethodSignature(token);
msig.ParseSignature(buffer, ref index);
Debug.Assert(index == buffer.Length, @"Signature parser didn't complete.");
return(msig);
}
/// <summary>
/// Parses the specified provider.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="token">The token.</param>
/// <returns></returns>
public static LocalVariableSignature Parse(IMetadataProvider provider, TokenTypes token)
{
byte[] buffer;
int index = 0;
provider.Read(token, out buffer);
LocalVariableSignature sig = new LocalVariableSignature();
sig.ParseSignature(buffer, ref index);
Debug.Assert(index == buffer.Length, @"Signature parser didn't complete.");
return(sig);
}
/// <summary>
/// Writes the generic param constraint table.
/// </summary>
/// <param name="metadataSource">The metadata source.</param>
/// <param name="metadataWriter">The metadata writer.</param>
private static void WriteGenericParamConstraintTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter)
{
GenericParamConstraintRow row;
WriteTable(TokenTypes.GenericParamConstraint, metadataSource, token =>
{
metadataSource.Read(token, out row);
metadataWriter.Write(row.OwnerTableIdx);
metadataWriter.WriteTypeDefOrRefIndex(row.ConstraintTableIdx);
});
}
/// <summary>
/// Writes the method spec table.
/// </summary>
/// <param name="metadataSource">The metadata source.</param>
/// <param name="metadataWriter">The metadata writer.</param>
private static void WriteMethodSpecTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter)
{
MethodSpecRow row;
WriteTable(TokenTypes.MethodSpec, metadataSource, token =>
{
metadataSource.Read(token, out row);
metadataWriter.WriteMethodDefOrRefIndex(row.MethodTableIdx);
metadataWriter.Write(row.InstantiationBlobIdx);
});
}
/// <summary>
/// Writes the nested class table.
/// </summary>
/// <param name="metadataSource">The metadata source.</param>
/// <param name="metadataWriter">The metadata writer.</param>
private static void WriteNestedClassTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter)
{
NestedClassRow row;
WriteTable(TokenTypes.NestedClass, metadataSource, token =>
{
metadataSource.Read(token, out row);
metadataWriter.Write(row.NestedClassTableIdx);
metadataWriter.Write(row.EnclosingClassTableIdx);
});
}
/// <summary>
/// Writes the field RVA table.
/// </summary>
/// <param name="metadataSource">The metadata source.</param>
/// <param name="metadataWriter">The metadata writer.</param>
private static void WriteFieldRVATable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter)
{
FieldRVARow row;
WriteTable(TokenTypes.FieldRVA, metadataSource, token =>
{
metadataSource.Read(token, out row);
metadataWriter.Write(row.Rva);
metadataWriter.Write(row.FieldTableIdx);
});
}
/// <summary>
/// Writes the property map table.
/// </summary>
/// <param name="metadataSource">The metadata source.</param>
/// <param name="metadataWriter">The metadata writer.</param>
private static void WritePropertyMapTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter)
{
PropertyMapRow row;
WriteTable(TokenTypes.PropertyMap, metadataSource, token =>
{
metadataSource.Read(token, out row);
metadataWriter.Write(row.ParentTableIdx);
metadataWriter.Write(row.PropertyTableIdx);
});
}
/// <summary>
/// Writes the event map table.
/// </summary>
/// <param name="metadataSource">The metadata source.</param>
/// <param name="metadataWriter">The metadata writer.</param>
private static void WriteEventMapTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter)
{
EventMapRow row;
WriteTable(TokenTypes.EventMap, metadataSource, token =>
{
metadataSource.Read(token, out row);
metadataWriter.Write(row.TypeDefTableIdx);
metadataWriter.Write(row.EventListTableIdx);
});
}
/// <summary>
/// Writes the interfaceimpl table.
/// </summary>
/// <param name="metadataSource">The metadata source.</param>
/// <param name="metadataWriter">The metadata writer.</param>
private static void WriteInterfaceImplTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter)
{
InterfaceImplRow row;
WriteTable(TokenTypes.InterfaceImpl, metadataSource, token =>
{
metadataSource.Read(token, out row);
metadataWriter.Write(row.ClassTableIdx);
metadataWriter.WriteTypeDefOrRefIndex(row.InterfaceTableIdx);
});
}
/// <summary>
/// Writes the field marshal table.
/// </summary>
/// <param name="metadataSource">The metadata source.</param>
/// <param name="metadataWriter">The metadata writer.</param>
private static void WriteFieldMarshalTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter)
{
FieldMarshalRow row;
WriteTable(TokenTypes.FieldMarshal, metadataSource, token =>
{
metadataSource.Read(token, out row);
metadataWriter.WriteHasFieldMarshalIndex(row.ParentTableIdx);
metadataWriter.Write(row.NativeTypeBlobIdx);
});
}
internal EventStoreStub(Action<T, string, DateTime> onSave)
{
this.onSave = onSave;
this.metadataProvider = new StandardMetadataProvider();
var constructor = typeof(T).GetConstructor(new[] { typeof(Guid), typeof(IEnumerable<IVersionedEvent>) });
if (constructor == null)
{
throw new InvalidCastException(
"Type T must have a constructor with the following signature: .ctor(Guid, IEnumerable<IVersionedEvent>)");
}
this.entityFactory = (id, events) => (T)constructor.Invoke(new object[] { id, events });
}
public OperationsFinalProcessingJob(
IMetadataProvider metadataProvider,
IMessageFlowProcessorFactory messageFlowProcessorFactory,
ISignInService signInService,
IUserImpersonationService userImpersonationService,
ITracer tracer)
: base(signInService, userImpersonationService, tracer)
{
_metadataProvider = metadataProvider;
_messageFlowProcessorFactory = messageFlowProcessorFactory;
_firstFaultTolerantStageSetting = new Lazy <MessageProcessingStage>(EvaluateFirstFaultTolerantStage);
}
private void AddPropertiesToNode(IMetadataProvider provider, TreeNode entityNode, IEnumerable <Property> properties)
{
foreach (Property property in properties.OrderBy(c => c.Name))
{
string name = DocumentationBuilder.ToNodeText(property);
var imageKey = ImageKeys.GetImageKey(property);
TreeNode node = CreateNode(provider, name, imageKey, property);
node.ToolTipText = DocumentationBuilder.ToToolTip(property, property);
node.NodeFont = NodeFont(property);
entityNode.Nodes.Add(node);
}
}
/// <summary>
/// Reads an (optional) custom modifier
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="buffer">The buffer to read the modifier From.</param>
/// <param name="index">The start index, where the modifier is expected.</param>
/// <returns></returns>
public static bool ReadCustomMod(IMetadataProvider provider, byte[] buffer, ref int index)
{
bool result = (buffer[index] == (byte)CilElementType.Required || buffer[index] == (byte)CilElementType.Optional);
if (result)
{
index++;
ReadTypeDefOrRefEncoded(provider, buffer, ref index);
Debug.WriteLine("Skipping CilElementType.Required or CilElementType.Optional.");
}
return(result);
}
/// <summary>
/// Writes the field layout table.
/// </summary>
/// <param name="metadataSource">The metadata source.</param>
/// <param name="metadataWriter">The metadata writer.</param>
private static void WriteFieldLayoutTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter)
{
FieldLayoutRow row;
WriteTable(TokenTypes.FieldLayout, metadataSource, token =>
{
metadataSource.Read(token, out row);
metadataWriter.Write(row.Offset);
metadataWriter.Write(row.Field);
});
}
public override GameMetadata DownloadGameData(string gameName, string id, IMetadataProvider provider)
{
CallCount++;
if (DownloadDataHandler != null)
{
return(DownloadDataHandler(gameName, id, provider));
}
else
{
return(base.DownloadGameData(gameName, id, provider));
}
}
private void WriteObjectMetadata(IMetadataProvider obj)
{
if (obj == null)
{
return;
}
foreach (var metadata in obj.GetMetadata())
{
_storageInstance.Writer.WriteElementString(metadata.Name, metadata.Value != null ? metadata.Value.ToString() : string.Empty);
}
}
public OperationsFinalProcessingJob(
IMetadataProvider metadataProvider,
IMessageFlowProcessorFactory messageFlowProcessorFactory,
ISignInService signInService,
IUserImpersonationService userImpersonationService,
ITracer tracer)
: base(signInService, userImpersonationService, tracer)
{
_metadataProvider = metadataProvider;
_messageFlowProcessorFactory = messageFlowProcessorFactory;
_firstFaultTolerantStageSetting = new Lazy<MessageProcessingStage>(EvaluateFirstFaultTolerantStage);
}
private static Documentation EntityDocumentation(IMetadataProvider provider, Entity entity)
{
var builder = new StringBuilder();
builder.AppendName(entity.FullName);
builder.Append($"Base type: {entity.BaseType}\r\n");
builder.AppendAccessControl(provider.ConnectionInfo, entity);
builder.AppendSummaryParagraph(entity.Summary);
var docs = builder.ToString();
return(new Documentation("Entity", docs));
}
public given_an_empty_event_log()
{
this.tableName = "AzureEventLogFixture" + new Random((int)DateTime.Now.Ticks).Next();
var settings = InfrastructureSettings.Read("Settings.xml").EventSourcing;
this.account = CloudStorageAccount.Parse(settings.ConnectionString);
this.eventA = new EventA();
this.eventB = new EventB();
this.eventC = new EventC();
this.metadata = Mock.Of <IMetadataProvider>(x =>
x.GetMetadata(eventA) == new Dictionary <string, string>
{
{ StandardMetadata.SourceId, eventA.SourceId.ToString() },
{ StandardMetadata.SourceType, "SourceA" },
{ StandardMetadata.Kind, StandardMetadata.EventKind },
{ StandardMetadata.AssemblyName, "A" },
{ StandardMetadata.Namespace, "Namespace" },
{ StandardMetadata.FullName, "Namespace.EventA" },
{ StandardMetadata.TypeName, "EventA" },
} &&
x.GetMetadata(eventB) == new Dictionary <string, string>
{
{ StandardMetadata.SourceId, eventB.SourceId.ToString() },
{ StandardMetadata.SourceType, "SourceB" },
{ StandardMetadata.Kind, StandardMetadata.EventKind },
{ StandardMetadata.AssemblyName, "B" },
{ StandardMetadata.Namespace, "Namespace" },
{ StandardMetadata.FullName, "Namespace.EventB" },
{ StandardMetadata.TypeName, "EventB" },
} &&
x.GetMetadata(eventC) == new Dictionary <string, string>
{
{ StandardMetadata.SourceId, eventC.SourceId.ToString() },
{ StandardMetadata.SourceType, "SourceC" },
{ StandardMetadata.Kind, StandardMetadata.EventKind },
{ StandardMetadata.AssemblyName, "B" },
{ StandardMetadata.Namespace, "AnotherNamespace" },
{ StandardMetadata.FullName, "AnotherNamespace.EventC" },
{ StandardMetadata.TypeName, "EventC" },
});
this.serializer = new JsonTextSerializer();
this.writer = new AzureMessageLogWriter(this.account, this.tableName);
this.sut = new AzureEventLogReader(this.account, this.tableName, new JsonTextSerializer());
this.startEnqueueTime = new DateTime(2012, 06, 30, 23, 59, 0, DateTimeKind.Utc);
Save(eventA, startEnqueueTime);
Save(eventB, startEnqueueTime.AddMinutes(5));
Save(eventC, startEnqueueTime.AddMinutes(6));
}
CheckRandomMetadata
(
IMetadataProvider oMetadataProvider,
Boolean bRandomMetadataExpected,
Boolean bRandomTagExpected,
Int32 iSeed
)
{
KeyValuePair <String, Object> [] aoRandomMetadata;
Object oRandomTag;
GetRandomMetadata(iSeed, out aoRandomMetadata, out oRandomTag);
foreach (KeyValuePair <String, Object> oRandomMetadata
in aoRandomMetadata)
{
String sRandomKey = oRandomMetadata.Key;
Object oRandomValue = oRandomMetadata.Value;
if (bRandomMetadataExpected)
{
Assert.IsTrue(oMetadataProvider.ContainsKey(sRandomKey));
Object oValue;
Assert.IsTrue(oMetadataProvider.TryGetValue(
sRandomKey,
(oRandomValue == null) ?
typeof(Object) : oRandomValue.GetType(),
out oValue
));
CheckMetadataValue(oRandomValue, oValue);
}
else
{
Assert.IsFalse(oMetadataProvider.ContainsKey(sRandomKey));
}
}
if (bRandomTagExpected)
{
CheckMetadataValue(oRandomTag, oMetadataProvider.Tag);
}
else
{
Assert.IsNull(oMetadataProvider.Tag);
}
}
/// <summary>
/// Creates an instance of a specific heap type.
/// </summary>
/// <param name="provider">The provider buffer, which contains the heap.</param>
/// <param name="type">The type of the heap to create.</param>
/// <param name="metadata">The metadata.</param>
/// <param name="offset">The offset into the buffer, where the heap starts.</param>
/// <param name="size">The size of the heap in bytes.</param>
/// <returns>An instance of the requested heap type.</returns>
/// <exception cref="System.ArgumentException">An invalid heap type was requested.</exception>
public static Heap CreateHeap(IMetadataProvider provider, HeapType type, byte[] metadata, int offset, int size)
{
switch (type)
{
case HeapType.String: return new StringHeap(metadata, offset, size);
case HeapType.Guid: return new GuidHeap(metadata, offset, size);
case HeapType.Blob: return new BlobHeap(metadata, offset, size);
case HeapType.UserString: return new UserStringHeap(metadata, offset, size);
case HeapType.Tables: return new TableHeap(provider, metadata, offset, size);
}
throw new ArgumentException(@"Invalid heap type.", @"type");
}
public FactsReplicator(
ITracer tracer,
IReplicationSettings replicationSettings,
IMetadataProvider metadataProvider,
IFactProcessorFactory factProcessorFactory,
IComparer<Type> factTypePriorityComparer)
{
_tracer = tracer;
_replicationSettings = replicationSettings;
_metadataProvider = metadataProvider;
_factProcessorFactory = factProcessorFactory;
_factTypePriorityComparer = factTypePriorityComparer;
}
public given_an_empty_event_log()
{
this.tableName = "AzureEventLogFixture" + new Random((int)DateTime.Now.Ticks).Next();
var settings = InfrastructureSettings.Read("Settings.xml").EventSourcing;
this.account = CloudStorageAccount.Parse(settings.ConnectionString);
this.eventA = new EventA();
this.eventB = new EventB();
this.eventC = new EventC();
this.metadata = Mock.Of<IMetadataProvider>(x =>
x.GetMetadata(eventA) == new Dictionary<string, string>
{
{ StandardMetadata.SourceId, eventA.SourceId.ToString() },
{ StandardMetadata.SourceType, "SourceA" },
{ StandardMetadata.Kind, StandardMetadata.EventKind },
{ StandardMetadata.AssemblyName, "A" },
{ StandardMetadata.Namespace, "Namespace" },
{ StandardMetadata.FullName, "Namespace.EventA" },
{ StandardMetadata.TypeName, "EventA" },
} &&
x.GetMetadata(eventB) == new Dictionary<string, string>
{
{ StandardMetadata.SourceId, eventB.SourceId.ToString() },
{ StandardMetadata.SourceType, "SourceB" },
{ StandardMetadata.Kind, StandardMetadata.EventKind },
{ StandardMetadata.AssemblyName, "B" },
{ StandardMetadata.Namespace, "Namespace" },
{ StandardMetadata.FullName, "Namespace.EventB" },
{ StandardMetadata.TypeName, "EventB" },
} &&
x.GetMetadata(eventC) == new Dictionary<string, string>
{
{ StandardMetadata.SourceId, eventC.SourceId.ToString() },
{ StandardMetadata.SourceType, "SourceC" },
{ StandardMetadata.Kind, StandardMetadata.EventKind },
{ StandardMetadata.AssemblyName, "B" },
{ StandardMetadata.Namespace, "AnotherNamespace" },
{ StandardMetadata.FullName, "AnotherNamespace.EventC" },
{ StandardMetadata.TypeName, "EventC" },
});
this.serializer = new JsonTextSerializer();
this.writer = new AzureMessageLogWriter(this.account, this.tableName);
this.sut = new AzureEventLogReader(this.account, this.tableName, new JsonTextSerializer());
this.startEnqueueTime = new DateTime(2012, 06, 30, 23, 59, 0, DateTimeKind.Utc);
Save(eventA, startEnqueueTime);
Save(eventB, startEnqueueTime.AddMinutes(5));
Save(eventC, startEnqueueTime.AddMinutes(6));
}
//*************************************************************************
// Method: CheckRandomMetadata()
//
/// <summary>
/// Checks the random metadata and Tag values on an object that implements
/// <see cref="IMetadataProvider" />.
/// </summary>
///
/// <param name="oMetadataProvider">
/// Object to check random metadata and Tag values on.
/// </param>
///
/// <param name="bRandomMetadataExpected">
/// true if the metadata was set with <see cref="SetRandomMetadata" />,
/// false if the metadata was left empty.
/// </param>
///
/// <param name="bRandomTagExpected">
/// true if the Tag was set with <see cref="SetRandomMetadata" />,
/// false if the Tag was left as null.
/// </param>
///
/// <param name="iSeed">
/// Seed to use for the random number generator.
/// </param>
///
/// <remarks>
/// This method checks the random metadata and Tag values that were set
/// with <see cref="SetRandomMetadata" />.
/// </remarks>
//*************************************************************************
public static void CheckRandomMetadata(
IMetadataProvider oMetadataProvider,
Boolean bRandomMetadataExpected,
Boolean bRandomTagExpected,
Int32 iSeed
)
{
KeyValuePair<String, Object> [] aoRandomMetadata;
Object oRandomTag;
GetRandomMetadata(iSeed, out aoRandomMetadata, out oRandomTag);
foreach (KeyValuePair<String, Object> oRandomMetadata
in aoRandomMetadata)
{
String sRandomKey = oRandomMetadata.Key;
Object oRandomValue = oRandomMetadata.Value;
if (bRandomMetadataExpected)
{
Assert.IsTrue( oMetadataProvider.ContainsKey(sRandomKey) );
Object oValue;
Assert.IsTrue( oMetadataProvider.TryGetValue(
sRandomKey,
(oRandomValue == null) ?
typeof(Object) : oRandomValue.GetType(),
out oValue
) );
CheckMetadataValue(oRandomValue, oValue);
}
else
{
Assert.IsFalse( oMetadataProvider.ContainsKey(sRandomKey) );
}
}
if (bRandomTagExpected)
{
CheckMetadataValue(oRandomTag, oMetadataProvider.Tag);
}
else
{
Assert.IsNull(oMetadataProvider.Tag);
}
}
public CommonReplicationStrategy(IMetadataProvider metadataProvider, Type entityType)
{
Guard.AgainstNull(metadataProvider, "metadataProvider");
Guard.AgainstNull(entityType, "entityType");
Guard.AgainstViolation(!entityType.IsNullable() && !entityType.IsArray,
"CommonReplicationStrategy is not applicable to nullable or array types");
this.entityType = entityType;
memberDescriptions = metadataProvider.GetFieldsReplicationInfo(entityType)
.Where(t => t.Behavior != ReplicationBehavior.Ignore)
.Select(t => new MemberReplicationInfo(entityType, t))
.ToArray();
}
/// <summary>
/// Computes the field offset.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="metadataProvider">The metadata provider.</param>
/// <param name="architecture">The architecture.</param>
/// <returns></returns>
public static int ComputeFieldOffset(ISignatureContext context, TokenTypes token, IMetadataProvider metadataProvider, IArchitecture architecture)
{
Metadata.Tables.TypeDefRow typeDefinition;
Metadata.Tables.TypeDefRow followingTypeDefinition;
metadataProvider.Read(token, out typeDefinition);
metadataProvider.Read(token + 1, out followingTypeDefinition);
int result = 0;
TokenTypes fieldList = typeDefinition.FieldList;
while (fieldList != token)
result += FieldSize(context, fieldList++, metadataProvider, architecture);
return result;
}
public DbModelFactory(IMetadataProvider metadataProvider, IClrTypeProvider clrTypeProvider)
{
if (metadataProvider == null)
{
throw new ArgumentNullException(nameof(metadataProvider));
}
if (clrTypeProvider == null)
{
throw new ArgumentNullException(nameof(clrTypeProvider));
}
_dbModelBuilderConfigurator = new DbModelBuilderConfigurator(metadataProvider, clrTypeProvider);
_metadataProvider = metadataProvider;
}
public static void Startup(TestContext context)
{
var connectionProperties = new Dictionary<string, string>();
//setup the initial parameters for data connection
connectionProperties.Add("Provider", "SQLNCLI10");
connectionProperties.Add("Server", "localhost");
connectionProperties.Add("Database", "ScribeSampleRSSource");
connectionProperties.Add("UserName", "sa");
//encrypt the connection password using the shared key
string encryptedPassword = Encryptor.Encrypt_AesManaged("sa", CryptoKey);
connectionProperties.Add("Password", encryptedPassword);
//open a new connection to the datasource
_sysConnector.Connect(connectionProperties);
//set an instance of the open metadata provider
_metadataProvider = _sysConnector.GetMetadataProvider();
}
/// <summary>
/// Fields the size.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="metadataProvider">The metadata provider.</param>
/// <param name="architecture">The architecture.</param>
/// <returns></returns>
public static int FieldSize(ISignatureContext context, TokenTypes field, IMetadataProvider metadataProvider, IArchitecture architecture)
{
Metadata.Tables.FieldRow fieldRow;
metadataProvider.Read(field, out fieldRow);
FieldSignature signature = Signature.FromMemberRefSignatureToken(context, metadataProvider, fieldRow.SignatureBlobIdx) as FieldSignature;
// If the field is another struct, we have to dig down and compute its size too.
if (signature.Type.Type == CilElementType.ValueType)
{
TokenTypes valueTypeSig = ValueTokenTypeFromSignature(metadataProvider, fieldRow.SignatureBlobIdx);
return ComputeTypeSize(context, valueTypeSig, metadataProvider, architecture);
}
int size, alignment;
architecture.GetTypeRequirements(signature.Type, out size, out alignment);
return size;
}
private void CustomizeEntity(IMetadataProvider metadataProvider, Uri entityElementId)
{
EntityElement entityElement;
if (!metadataProvider.TryGetMetadata(entityElementId, out entityElement))
{
throw new ArgumentException();
}
// ограничение для серверного paging
PageSize = 100;
// убрали ограничение, вернуть когда в ODATA появится $filter=Id in [1, 2, 3]
MaxNodeCount = int.MaxValue;
// запреты
AllowedArithmeticOperators = AllowedArithmeticOperators.None;
AllowedFunctions = AllowedFunctions.All | AllowedFunctions.Any;
}
/// <summary>
/// Initializes a new instance of the <see cref="MetadataProxy"/> class.
/// </summary>
/// <param name="metadataService">The metadata service.</param>
/// <param name="metadataProvider">The metadata provider.</param>
/// <param name="childMetadataName">Name of the child metadata.</param>
public MetadataProxy(
IMetadataService metadataService,
IMetadataProvider metadataProvider,
string childMetadataName )
{
if ( metadataService == null )
{
throw new ArgumentNullException ( "metadataService" );
}
if ( metadataProvider == null )
{
throw new ArgumentNullException ( "metadataProvider" );
}
_metadataService = metadataService;
_metadataProvider = metadataProvider;
_childMetadataName = childMetadataName;
InitializeProxy ();
}
/// <summary>
/// Froms the member ref signature token.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="token">The token.</param>
/// <returns></returns>
public static Signature FromMemberRefSignatureToken(ISignatureContext context, IMetadataProvider provider, TokenTypes token)
{
Signature result;
int index = 0;
byte[] buffer;
provider.Read(token, out buffer);
if (0x06 == buffer[0])
{
result = new FieldSignature();
result.ParseSignature(context, buffer, ref index);
}
else
{
result = new MethodSignature();
result.ParseSignature(context, buffer, ref index);
}
Debug.Assert(index == buffer.Length, @"Not all signature bytes read.");
return result;
}
