public async Task GivenTankWithoutUserId_ReturnsEmptyCollection()
{
// Arrange
var query = new GetTanksByUserIdQuery
{
UserId = Guid.NewGuid()
};
var tankOne = new TankEntity
{
Id = Guid.NewGuid(),
UserId = Guid.NewGuid()
};
var tankTwo = new TankEntity
{
Id = Guid.NewGuid(),
UserId = Guid.NewGuid()
};
await _tankCollection.InsertManyAsync(new [] { tankOne, tankTwo });
// Act
var result = await _classUnderTest.Handle(query, CancellationToken.None);
// Assert
CollectionAssert.IsEmpty(result);
}
void EndTurn()
{
TankEntity currPlayer = playerTanks[currentPlayerIndex];
TankControls controls = currPlayer.GetComponent <TankControls>();
controls.EnableInput(false);
IncreasePlayerIndex();
}
void BeginTurn()
{
TankEntity currPlayer = playerTanks[currentPlayerIndex];
TankControls controls = currPlayer.GetComponent <TankControls>();
controls.EnableInput(true);
currPlayer.Select();
}
void Update()
{
if (co == null)
{
co = entitiesGroup.ExcuteOnEntitiesCo((entity) =>
{
tank = (TankEntity)entity;
tank.Head.LookAt(Target.value);
// Debug.DrawLine(tank.Head.position, Target.value.position,Color.red);
}, this, true);
}
}
public static TankListDto ToDto(this TankEntity tank)
{
return(new TankListDto
{
Id = tank.Id,
Name = tank.Name,
WaterList = tank.Water?.ToDto(),
Livestock = tank.Livestock?
.Select(tankLivestock => tankLivestock.ToDto())
.ToList(),
Supplies = tank.Supplies?
.Select(tankSupply => tankSupply.ToDto())
.ToList()
});
}
public void Refuel(TankEntity entity)
{
int needed = maxCharge - charge;
int available = entity.charge;
if (needed > 0)
{
if (available >= needed)
{
charge += needed;
entity.charge -= needed;
}
else
{
charge += entity.charge;
entity.charge = 0;
}
}
}
public async Task GivenTankDoesExist_RespondsWithTank()
{
// Arrange
var userId = Guid.NewGuid();
var tankId = Guid.NewGuid();
var bearerToken = new TestBearerTokenBuilder()
.WithUserId(userId)
.WithRole(UserRole.Standard)
.Build();
HttpClient.SetBearerToken(bearerToken);
var user = new UserEntity
{
Id = userId
};
var tank = new TankEntity
{
Id = tankId,
UserId = userId
};
await _userCollection.InsertOneAsync(user);
await _tankCollection.InsertOneAsync(tank);
// Act
var response = await HttpClient.GetAsync(_url);
// Assert
var responseData = await response.Content.ReadFromJsonAsync <IEnumerable <TankResponse> >();
Assert.Multiple(() =>
{
Assert.That(responseData.Count(), Is.EqualTo(1));
var resultingTankResponse = responseData.FirstOrDefault();
Assert.That(resultingTankResponse.Id, Is.EqualTo(tankId));
});
}
public async Task GivenTankWithUserId_ReturnsTank()
{
// Arrange
var userId = Guid.NewGuid();
var query = new GetTanksByUserIdQuery
{
UserId = userId
};
var tankOne = new TankEntity
{
Id = Guid.NewGuid(),
UserId = userId
};
var tankTwo = new TankEntity
{
Id = Guid.NewGuid(),
UserId = userId
};
await _tankCollection.InsertManyAsync(new [] { tankOne, tankTwo });
// Act
var result = await _classUnderTest.Handle(query, CancellationToken.None);
// Assert
Assert.Multiple(() =>
{
Assert.That(result.Count, Is.EqualTo(2));
var resultingTankOne = result.FirstOrDefault();
Assert.That(resultingTankOne, Is.Not.Null);
Assert.That(resultingTankOne.Id, Is.EqualTo(tankOne.Id));
var resultingTankTwo = result.LastOrDefault();
Assert.That(resultingTankTwo, Is.Not.Null);
Assert.That(resultingTankTwo.Id, Is.EqualTo(tankTwo.Id));
});
}
public void GivenTankEntity_ReturnsTankDto()
{
// Arrange
var tank = new TankEntity
{
Id = Guid.NewGuid(),
UserId = Guid.NewGuid(),
Name = "This is a tank.",
Water = new TankWaterStub
{
WaterId = Guid.NewGuid(),
Stage = WaterCycleStage.BuildingAnaerobic,
Levels = new List <TankWaterLevelStub>
{
new TankWaterLevelStub
{
Metric = Metric.Units,
Quantity = 23
}
}
},
Livestock = new List <TankLivestockStub>
{
new TankLivestockStub
{
LivestockId = Guid.NewGuid(),
Name = "This is a livestock.",
Sex = LivestockSex.Female,
Happiness = TankLivestockHappiness.Happy,
Healthy = true,
LastFed = DateTime.UtcNow,
UntilNextFeed = new TimeSpan(1, 1, 1, 1, 1)
}
},
Supplies = new List <TankSupplyStub>
{
new TankSupplyStub
{
SupplyId = Guid.NewGuid(),
Name = "This is a supply.",
Component = TankSupplyComponent.Filter,
Metric = Metric.Units,
Quantity = 23
}
}
};
// Act
var result = tank.ToDto();
// Assert
Assert.Multiple(() =>
{
Assert.That(result.Id, Is.EqualTo(tank.Id));
Assert.That(result.Name, Is.EqualTo(tank.Name));
Assert.That(result.WaterList.WaterId, Is.EqualTo(tank.Water.WaterId));
Assert.That(result.WaterList.Stage, Is.EqualTo(tank.Water.Stage));
var tankWaterLevel = tank.Water.Levels.FirstOrDefault();
var resultingTankWaterLevel = result.WaterList.Levels.FirstOrDefault();
Assert.That(resultingTankWaterLevel, Is.Not.Null);
Assert.That(resultingTankWaterLevel.Metric, Is.EqualTo(tankWaterLevel.Metric));
Assert.That(resultingTankWaterLevel.Quantity, Is.EqualTo(tankWaterLevel.Quantity));
var livestock = tank.Livestock.FirstOrDefault();
var resultingLivestock = result.Livestock.FirstOrDefault();
Assert.That(resultingLivestock.LivestockId, Is.EqualTo(livestock.LivestockId));
Assert.That(resultingLivestock.Name, Is.EqualTo(livestock.Name));
Assert.That(resultingLivestock.Sex, Is.EqualTo(livestock.Sex));
Assert.That(resultingLivestock.Happiness, Is.EqualTo(livestock.Happiness));
Assert.That(resultingLivestock.Healthy, Is.EqualTo(livestock.Healthy));
Assert.That(resultingLivestock.LastFed, Is.EqualTo(livestock.LastFed));
Assert.That(resultingLivestock.UntilNextFeed, Is.EqualTo(livestock.UntilNextFeed));
var supply = tank.Supplies.FirstOrDefault();
var resultingSupply = result.Supplies.FirstOrDefault();
Assert.That(resultingSupply.SupplyId, Is.EqualTo(supply.SupplyId));
Assert.That(resultingSupply.Name, Is.EqualTo(supply.Name));
Assert.That(resultingSupply.Component, Is.EqualTo(supply.Component));
Assert.That(resultingSupply.Metric, Is.EqualTo(supply.Metric));
Assert.That(resultingSupply.Quantity, Is.EqualTo(supply.Quantity));
});
}
public async Task GivenTankWithUserId_ReturnsLicense()
{
// Arrange
var tankId = Guid.NewGuid();
var userId = Guid.NewGuid();
var user = new UserEntity
{
Id = userId
};
var tank = new TankEntity
{
Id = tankId,
UserId = userId,
Name = "This is a tank.",
Water = new TankWaterStub
{
WaterId = Guid.NewGuid(),
Stage = WaterCycleStage.BuildingAnaerobic,
Levels = new List <TankWaterLevelStub>
{
new TankWaterLevelStub
{
Metric = Metric.Units,
Quantity = 23
}
}
},
Livestock = new List <TankLivestockStub>
{
new TankLivestockStub
{
LivestockId = Guid.NewGuid(),
Name = "This is a livestock.",
Sex = LivestockSex.Female,
Happiness = TankLivestockHappiness.Happy,
Healthy = true,
LastFed = DateTime.UtcNow,
UntilNextFeed = new TimeSpan(1, 1, 1, 1, 1)
}
},
Supplies = new List <TankSupplyStub>
{
new TankSupplyStub
{
SupplyId = Guid.NewGuid(),
Name = "This is a supply.",
Component = TankSupplyComponent.Filter,
Metric = Metric.Units,
Quantity = 23
}
}
};
_mediator
.SetupHandler <GetUserByIdQuery, UserEntity>()
.ReturnsAsync(user);
_mediator
.SetupHandler <GetTanksByUserIdQuery, IList <TankEntity> >()
.ReturnsAsync(new List <TankEntity> {
tank
});
// Act
var result = await _classUnderTest.GetByUserIdAsync(userId, CancellationToken.None);
// Assert
var resultingTank = result.FirstOrDefault();
Assert.That(resultingTank.Id, Is.EqualTo(tankId));
}
// End of custom references
private void Awake()
{
TankEntity = GetComponent <TankEntity>();
TimeBetweenRefresh = PlayerPrefs.GetInt(Properties.PlayerPrefs.SecondsBetweenRefresh, Properties.PlayerPrefsDefault.SecondsBetweenRefresh);
AlwaysPickBestChoice = PlayerPrefsUtils.GetBool(Properties.PlayerPrefs.AlwaysPickBestChoice, Properties.PlayerPrefsDefault.AlwaysPickBestChoice);
}
