public void ReservaAprovadaDeveLevantarExcecaoDeReservaNaoEstaAguardandoAprovacao()
{
var gerenciador = new GerenciadorReservas(Substitute.For <ITransactionContextFactory>(),
Substitute.For <ICarrosDao>(),
Substitute.For <IReservasDao>(),
Substitute.For <IPessoasDao>());
var reserva = new EntityBuilder <IReservas>().Build();
reserva.Status = ReservasStatusListaItens.ItemReservado;
gerenciador.AprovarReserva(reserva);
}
public void ToPizzaItemEntity_IngredientsAreNull_NullReferenceException()
{
PizzaItemDto expected = new PizzaItemDto(
"Margarita",
200,
"Margarita.png",
DateTime.Now,
new List <IngredientDto>());
expected.Ingredients = null;
PizzaItem actual = EntityBuilder.ToEntity(expected);
}
public void TestMethod1()
{
var metadata = MetadataProvider.Entity("SR");
var wo = JObject.Parse(new StreamReader("jsons\\sr\\creation1.json").ReadToEnd());
var data = EntityBuilder.BuildFromJson <CrudOperationData>(typeof(CrudOperationData), metadata, null, wo, null);
var result = TargetAttributesHandler.SetValuesFromJSON(new ServiceIncident(), metadata, data);
Assert.IsNotNull(result.Problem);
Assert.AreEqual(result.WorkflowStatus, "new");
Assert.AreEqual(result.Problem.Abstract, "test");
Assert.IsNotNull(result.Metrics.ProblemOccurredDateTime);
}
public void CanBuildEntityWithKey()
{
var expected = CreateContext(new Entity("Test", DefaultProps["Id"], DefaultProps));
var actual = new EntityBuilder()
.Name("Test")
.Source(NullDataSource.Instance)
.Id("Id", TypeSystem.Integer)
.AddProperty("Name", TypeSystem.String)
.Build();
Assert.Equal(expected, actual, EntityContextComparer.Instance);
}
public void ToEntityIngredient_IngredientImageMainUrlIsNull_IngredientDtoIsEqualToIngredient()
{
IngredientDto ingredient = new IngredientDto(
"Tomato",
(decimal)10.0,
"ImageUrl.png",
null,
new CategoryDto(Categories.Vegetables.ToString()),
-200);
Ingredient result = EntityBuilder.ToEntity(ingredient);
base.AssertIngredientsAreEqual(result, ingredient);
}
public static Entity CreateTileTemplate(Vector3 position)
{
var tileTemplate = EntityBuilder.Begin()
.AddPositionComponent(position, CommonRequirementSets.PhysicsOnly)
.AddMetadataComponent(entityType: SimulationSettings.TilePrefabName)
.SetPersistence(true)
.SetReadAcl(Acl.MakeRequirementSet(CommonAttributeSets.Physics, CommonAttributeSets.Visual, Acl.MakeAttributeSet("turret_rotation")))
.AddComponent(new Improbable.Demo.PositionColor.Data(0), CommonRequirementSets.PhysicsOnly)
.AddComponent(new Improbable.Demo.CheckOutColor.Data(new List <uint>()), CommonRequirementSets.PhysicsOnly)
.Build();
return(tileTemplate);
}
public void ByOnBuildsToCorrectResult()
{
var entityBuilder = new EntityBuilder(Entity.Enemy, Entity.Totem);
var sut = CreateSut();
var result = sut.By(entityBuilder).On.Build();
var statBuilder = result.StatConverter(InputStat);
IReadOnlyList <IStat> stats = statBuilder.BuildToSingleResult().Stats;
Assert.That(stats, Has.Exactly(2).Items);
Assert.AreEqual("Character.stat.On(test).By(Enemy)", stats[0].ToString());
Assert.AreEqual("Character.stat.On(test).By(Totem)", stats[1].ToString());
}
public void OnBuildsToCorrectResults()
{
var entityBuilder = new EntityBuilder(Entity.Enemy);
var sut = CreateSut();
var on = sut.On(entityBuilder);
var stats = on.BuildToSingleResult().Stats;
Assert.That(stats, Has.Exactly(3).Items);
Assert.AreEqual("Enemy.test.Active", stats[0].ToString());
Assert.AreEqual("Enemy.test.BuffActive", stats[1].ToString());
Assert.AreEqual("Enemy.test.BuffSourceIs(Character)", stats[2].ToString());
}
public static Entity CreatePlayer(int clientID)
{
var player = new EntityBuilder(World, Engine, Level, EntityType.PLAYER)
.Net()
.build();
player.AddComponent <ClientComponent>().ID = clientID;
player.AddComponent <ResourceComponent>().OreAmount = 0;
player.AddComponent <TaskFactoryComponent>().Set(new TaskFactory(Engine));
player.AddComponent <TaskQueueComponent>();
player.AddComponent <OwnedWorkersComponent>().Set(maxWorkers: Constants.MAX_WORKERS_PER_PLAYER);
return(player);
}
// Template definition for a SmallFish snapshot entity
static public Entity GenerateSmallFishTemplate(Vector3 initialPosition)
{
var smallFishTemplate = EntityBuilder.Begin()
// Add components to the entity, then set the access permissions for the component on the entity relative to the client or server worker ids.
.AddPositionComponent(initialPosition, CommonRequirementSets.PhysicsOnly)
.AddMetadataComponent(SimulationSettings.SmallFishPrefabName)
.SetPersistence(true)
.SetReadAcl(CommonRequirementSets.PhysicsOrVisual)
.AddComponent(new Rotation.Data(0), CommonRequirementSets.PhysicsOnly)
.Build();
return(smallFishTemplate);
}
// Defines the template for the PlayerCreator entity.
public static Entity CreatePlayerCreatorTemplate()
{
var playerCreatorEntityTemplate = EntityBuilder.Begin()
// Add components to the entity, then set the access permissions for the component on the entity relative to the client or server worker ids.
.AddPositionComponent(new Vector3(-5, 0, 0), CommonRequirementSets.PhysicsOnly)
.AddMetadataComponent(SimulationSettings.PlayerCreatorPrefabName)
.SetPersistence(true)
.SetReadAcl(CommonRequirementSets.PhysicsOrVisual)
.AddComponent(new PlayerCreation.Data(), CommonRequirementSets.PhysicsOnly)
.Build();
return(playerCreatorEntityTemplate);
}
public static Entity CreateArmchairEntityTemplate(Improbable.Coordinates spawnPosition, float rotation)
{
var entityTemplate = EntityBuilder.Begin()
.AddPositionComponent(spawnPosition.ToUnityVector(), CommonRequirementSets.PhysicsOnly)
.AddMetadataComponent(entityType: SimulationSettings.ArmchairPrefabName)
.SetPersistence(true)
.SetReadAcl(CommonRequirementSets.PhysicsOrVisual)
.AddComponent(new Rotation.Data(Quaternion.Euler(0, rotation, 0).ToNativeQuaternion()), CommonRequirementSets.PhysicsOnly)
.AddComponent(new Grabbable.Data(new Option <CurrentGrabberInfo>()), CommonRequirementSets.PhysicsOnly)
.Build();
return(entityTemplate);
}
public List <T> GetEntities <T>(IDatabaseCommand dataCommand) where T : class
{
var result = new List <T>();
using (var reader = CreateDbCommnad(dataCommand).ExecuteReader())
{
while (reader.Read())
{
result.Add((T)EntityBuilder.GetBuilder(typeof(T)).Build(reader));
}
}
return(result);
}
public static Entity CreateNoticeTemplate(string text, Coordinates coordinates)
{
var noticeTemplate = EntityBuilder.Begin()
.AddPositionComponent(coordinates.ToUnityVector(), CommonRequirementSets.PhysicsOnly)
.AddMetadataComponent(entityType: SimulationSettings.NoticePrefabName)
.SetPersistence(true)
.SetReadAcl(CommonRequirementSets.PhysicsOrVisual)
.AddComponent(new Rotation.Data(Quaternion.identity.ToNativeQuaternion()), CommonRequirementSets.PhysicsOnly)
.AddComponent(new Notice.Data(text), CommonRequirementSets.PhysicsOnly)
.Build();
return(noticeTemplate);
}
public void ByRecentlyBuildsToCorrectResult()
{
var entityBuilder = new EntityBuilder(Entity.Enemy);
var lastOccurenceStat = new Stat("test.LastOccurrence", Entity.Enemy);
var context = Mock.Of <IValueCalculationContext>(c =>
c.GetValue(lastOccurenceStat, NodeType.Total, PathDefinition.MainPath) == new NodeValue(1));
var sut = CreateSut();
var result = sut.By(entityBuilder).Recently.Build();
var actual = result.Value.Calculate(context);
Assert.IsTrue(actual.IsTrue());
}
public static Entity CreatePlayerCreatorTemplate()
{
var playerCreatorEntityTemplate = EntityBuilder.Begin()
.AddPositionComponent(Improbable.Coordinates.ZERO.ToUnityVector(), CommonRequirementSets.PhysicsOnly)
.AddMetadataComponent(entityType: SimulationSettings.PlayerCreatorPrefabName)
.SetPersistence(true)
.SetReadAcl(CommonRequirementSets.PhysicsOrVisual)
.AddComponent(new Rotation.Data(Quaternion.identity.ToNativeQuaternion()), CommonRequirementSets.PhysicsOnly)
.AddComponent(new PlayerCreation.Data(), CommonRequirementSets.PhysicsOnly)
.Build();
return(playerCreatorEntityTemplate);
}
public static Entity CreateDroneTemplate(Improbable.Coordinates spawnPoint, Vector3f initialTarget, EntityId controller, float payloadWeight, float droneSpeed = SimulationSettings.MaxDroneSpeed)
{
var droneTemplate = EntityBuilder.Begin()
.AddPositionComponent(spawnPoint.ToUnityVector(), CommonRequirementSets.PhysicsOnly)
.AddMetadataComponent(entityType: SimulationSettings.DronePrefabName)
.SetPersistence(true)
.SetReadAcl(CommonRequirementSets.PhysicsOrVisual)
.AddComponent(new Rotation.Data(Quaternion.identity.ToNativeQuaternion()), CommonRequirementSets.PhysicsOnly)
.AddComponent(new DroneData.Data(initialTarget, Mathf.Min(SimulationSettings.MaxDroneSpeed, droneSpeed), new Vector3f(), TargetPending.REQUEST, DroneStatus.MOVE, 0, payloadWeight, new Vector3f(0, -1, 0), controller), CommonRequirementSets.PhysicsOnly)
.Build();
return(droneTemplate);
}
private static void AddPlayerSpawner(Snapshot snapshot)
{
var playerCreator = SpatialOSPlayerCreator.CreateSchemaComponentData();
var spawner = EntityBuilder.Begin()
.AddPosition(0, 0, 0, SystemConfig.UnityGameLogic)
.AddMetadata("PlayerCreator", SystemConfig.UnityGameLogic)
.SetPersistence(true)
.SetReadAcl(UnityWorkers)
.AddComponent(playerCreator, SystemConfig.UnityGameLogic)
.Build();
snapshot.AddEntity(spawner);
}
public static Entity CreatePirateEntityTemplate(Vector3 initialPosition, uint initialRotation)
{
var pirateEntityTemplate = EntityBuilder.Begin()
.AddPositionComponent(initialPosition, CommonRequirementSets.PhysicsOnly)
.AddMetadataComponent(SimulationSettings.PirateShipPrefabName)
.SetPersistence(true)
.SetReadAcl(CommonRequirementSets.PhysicsOrVisual)
.AddComponent(new Rotation.Data(initialRotation), CommonRequirementSets.PhysicsOnly)
.AddComponent(new ShipControls.Data(0, 0), CommonRequirementSets.PhysicsOnly)
.Build();
return(pirateEntityTemplate);
}
private static void AddPlayerSpawner(Snapshot snapshot)
{
var playerCreator = PlayerCreator.Component.CreateSchemaComponentData();
var spawner = EntityBuilder.Begin()
.AddPosition(0, 0, 0, WorkerUtils.UnityGameLogic)
.AddMetadata("PlayerCreator", WorkerUtils.UnityGameLogic)
.SetPersistence(true)
.SetReadAcl(WorkerUtils.AllWorkerAttributes)
.AddComponent(playerCreator, WorkerUtils.UnityGameLogic)
.Build();
snapshot.AddEntity(spawner);
}
private static void RunTemplateBuilders(string solutionDirectory, ApiTemplate template, IFileSystem fileSystem)
{
// dbcontext
DbContextBuilder.CreateDbContext(solutionDirectory, template);
//entities
foreach (var entity in template.Entities)
{
EntityBuilder.CreateEntity(solutionDirectory, entity, fileSystem);
DtoBuilder.CreateDtos(solutionDirectory, entity);
RepositoryBuilder.AddRepository(solutionDirectory, entity, template.DbContext);
ValidatorBuilder.CreateValidators(solutionDirectory, entity);
ProfileBuilder.CreateProfile(solutionDirectory, entity);
ControllerBuilder.CreateController(solutionDirectory, entity);
FakesBuilder.CreateFakes(solutionDirectory, template, entity);
ReadTestBuilder.CreateEntityReadTests(solutionDirectory, template, entity);
GetTestBuilder.CreateEntityGetTests(solutionDirectory, template, entity);
PostTestBuilder.CreateEntityWriteTests(solutionDirectory, template, entity);
UpdateTestBuilder.CreateEntityUpdateTests(solutionDirectory, template, entity);
DeleteTestBuilder.DeleteEntityWriteTests(solutionDirectory, template, entity);
WebAppFactoryBuilder.CreateWebAppFactory(solutionDirectory, template, entity);
}
// environments
AddStartupEnvironmentsWithServices(solutionDirectory, template);
//seeders
SeederBuilder.AddSeeders(solutionDirectory, template);
//services
SwaggerBuilder.AddSwagger(solutionDirectory, template);
if (template.AuthSetup.AuthMethod == "JWT")
{
IdentityServicesModifier.SetIdentityOptions(solutionDirectory, template.AuthSetup);
IdentitySeederBuilder.AddSeeders(solutionDirectory, template);
IdentityRoleBuilder.CreateRoles(solutionDirectory, template.AuthSetup.Roles);
RoleSeedBuilder.SeedRoles(solutionDirectory, template);
}
//final
ReadmeBuilder.CreateReadme(solutionDirectory, template, fileSystem);
if (template.AddGit)
{
GitSetup(solutionDirectory);
}
}
public static IEntity CreateClient(this EntityFactory factory, INetworkClient client)
{
var entity = EntityBuilder.Create()
.AddComponent <NetworkComponent>()
.AddComponent <AccountComponent>()
.Build(EntityManager.Instance.GetNextId());
entity.GetComponent <NetworkComponent>().Client = client;
entity.RefId = client.Id;
EntityManager.Instance.Add(entity);
return(entity);
}
public static EntityTemplate Player(string workerId, Vector3f position)
{
const string gameLogic = WorkerUtils.UnityGameLogic;
var client = $"workerId:{workerId}";
var(spawnPosition, spawnYaw, spawnPitch) = SpawnPoints.GetRandomSpawnPoint();
var serverResponse = new ServerResponse
{
Position = spawnPosition.ToIntAbsolute()
};
var serverMovement = ServerMovement.Component.CreateSchemaComponentData(serverResponse);
var clientMovementData = new ClientRequest();
var rotationUpdate = new RotationUpdate
{
Yaw = spawnYaw.ToInt1k(),
Pitch = spawnPitch.ToInt1k()
};
var clientMovement = ClientMovement.Component.CreateSchemaComponentData(clientMovementData);
var clientRotation = ClientRotation.Component.CreateSchemaComponentData(rotationUpdate);
var shootingComponent = ShootingComponent.Component.CreateSchemaComponentData();
var gunStateComponent = GunStateComponent.Component.CreateSchemaComponentData(false);
var gunComponent = GunComponent.Component.CreateSchemaComponentData(PlayerGunSettings.DefaultGunIndex);
var maxHealth = PlayerHealthSettings.MaxHealth;
var healthComponent = HealthComponent.Component.CreateSchemaComponentData(maxHealth, maxHealth);
var healthRegenComponent = HealthRegenComponent.Component.CreateSchemaComponentData(false,
0,
PlayerHealthSettings.SpatialCooldownSyncInterval,
PlayerHealthSettings.RegenAfterDamageCooldown,
PlayerHealthSettings.RegenInterval,
PlayerHealthSettings.RegenAmount);
return(EntityBuilder.Begin()
.AddPosition(spawnPosition.x, spawnPosition.y, spawnPosition.z, gameLogic)
.AddMetadata("Player", gameLogic)
.SetPersistence(false)
.SetReadAcl(AllWorkerAttributes)
.AddComponent(serverMovement, gameLogic)
.AddComponent(clientMovement, client)
.AddComponent(clientRotation, client)
.AddComponent(shootingComponent, client)
.AddComponent(gunComponent, gameLogic)
.AddComponent(gunStateComponent, client)
.AddComponent(healthComponent, gameLogic)
.AddComponent(healthRegenComponent, gameLogic)
.AddPlayerLifecycleComponents(workerId, client, gameLogic)
.Build());
}
public void ToEntityPizzaTemplate_IngredientsAreEmpty_PizzaTemplateDtoIsEqualToPizzaTemplate()
{
TemplateDto expected = new TemplateDto(
"Template",
700,
"ImageUrl.png",
new List <IngredientDto>());
expected.Ingredients = new List <IngredientDto>();
PizzaTemplate actual = EntityBuilder.ToEntity(expected);
base.AssertPizzaTemplatesAreEqual(actual, expected);
}
public void EntityBuilder_CreateEntity_throws_error_if_file_exists()
{
var solutionDirectory = @"c:\myrepo";
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(solutionDirectory);
var entity = CannedGenerator.FakeBasicProduct();
var expectedFilePath = ClassPathHelper.EntityClassPath(solutionDirectory, $"{entity.Name}.cs").FullClassPath;
fileSystem.AddFile(expectedFilePath, new MockFileData("content doesn't matter"));
Assert.Throws <FileAlreadyExistsException>(() => EntityBuilder.CreateEntity(solutionDirectory, entity, fileSystem));
}
private static Func <int, Unit, Entity> WrapWithPlayerFn(EncounterState state, Func <int, Unit, Entity> unitFn, int playerFormationNum)
{
return(delegate(int formationNum, Unit unit) {
if (formationNum == playerFormationNum)
{
AddPlayerToUnit(state.Player, unit, playerFormationNum);
return state.Player;
}
else
{
return EntityBuilder.CreateHastatusEntity(state.CurrentTick, formationNum, unit, FactionName.PLAYER);
}
});
}
public static Entity CreatePlayerTemplate(string clientId)
{
var playerTemplate = EntityBuilder.Begin()
.AddPositionComponent(Improbable.Coordinates.ZERO.ToUnityVector(), CommonRequirementSets.PhysicsOnly)
.AddMetadataComponent(entityType: SimulationSettings.PlayerPrefabName)
.SetPersistence(false)
.SetReadAcl(CommonRequirementSets.PhysicsOrVisual)
.AddComponent(new Rotation.Data(Quaternion.identity.ToNativeQuaternion()), CommonRequirementSets.PhysicsOnly)
.AddComponent(new ClientAuthorityCheck.Data(), CommonRequirementSets.SpecificClientOnly(clientId))
.AddComponent(new ClientConnection.Data(SimulationSettings.TotalHeartbeatsBeforeTimeout), CommonRequirementSets.PhysicsOnly)
.Build();
return(playerTemplate);
}
protected override void VisitNumericLiteral(NumericLiteral item)
{
var sqlValue = ParseNumericLiteralValue(item);
if (CurrentUpdateStatementPart == UpdateStatementPart.WhereClause)
{
IdFilterValue = sqlValue;
}
else
{
var attName = GetColumnLogicalAttributeName(this.CurrentSetterColumn);
EntityBuilder.WithAttribute(attName).SetValueWithTypeCoersion(sqlValue);
}
}
public static EntityBuilder AddPlayerLifecycleComponents(this EntityBuilder entityBuilder,
string workerId,
string clientAccess,
string serverAccess)
{
var clientHeartbeat = PlayerHeartbeatClient.Component.CreateSchemaComponentData();
var serverHeartbeat = PlayerHeartbeatServer.Component.CreateSchemaComponentData();
var owningComponent = OwningWorker.Component.CreateSchemaComponentData(workerId);
return(entityBuilder
.AddComponent(clientHeartbeat, clientAccess)
.AddComponent(serverHeartbeat, serverAccess)
.AddComponent(owningComponent, serverAccess));
}
protected override void VisitPlaceholder(Placeholder item)
{
var paramVal = GetParamaterValue(item.Value);
if (CurrentUpdateStatementPart == UpdateStatementPart.WhereClause)
{
IdFilterValue = paramVal;
}
else
{
var attName = GetColumnLogicalAttributeName(this.CurrentSetterColumn);
EntityBuilder.WithAttribute(attName).SetValueWithTypeCoersion(paramVal);
}
}
private Regulus.Project.TurnBasedRPG.Data.Entity _Build(EntityBuilder.Kind kind, GameObject game_object)
{
if (kind == EntityBuilder.Kind.Static)
{
Regulus.Project.TurnBasedRPG.Data.StaticEntity entity = new Regulus.Project.TurnBasedRPG.Data.StaticEntity();
return _Build(entity , game_object);
}
if (kind == EntityBuilder.Kind.Portal)
{
Regulus.Project.TurnBasedRPG.Data.PortalEntity entity = new Regulus.Project.TurnBasedRPG.Data.PortalEntity();
return _Build(entity , game_object);
}
throw new System.Exception("�S��������Entity Builder " + kind);
}
public IEntityBuilder Alter()
{
var builder = new EntityBuilder(EntityState.Altering);
schema.Add(builder);
return builder;
}
public IEntityBuilder Drop()
{
var builder = new EntityBuilder(EntityState.Deleting);
schema.Add(builder);
return builder;
}
public IEntityBuilder Create()
{
var builder = new EntityBuilder(EntityState.Creating);
schema.Add(builder);
return builder;
}
public IoBuilder(EntityBuilder entityBuilder, TflIo output) {
_entityBuilder = entityBuilder;
_output = output;
}
