public void Finds10Clients()
{
var db = new MockDB();
// Clients that need review
for (int i = 0; i < 10; i++)
{
db.Add(new Client()
{
NextReview = DateTime.Today.SubtractDays(i)
});
}
// Clients that don't need review
for (int i = 0; i < 10; i++)
{
db.Add(new Client()
{
NextReview = DateTime.Today.AddDays(i)
});
}
var s = new ClientSearcher(db);
var r = s.Find(c => c.NextReview <= DateTime.Today);
Assert.AreEqual(10, r.Count);
}
public ActionResult Create(Sms new1) // New Message Controller with a HttpPost
{
if (ModelState.IsValid) //Checks if the Sms model is Valid
{
MockDB newDb = new MockDB(); // Creates new Database Object
string checkList = newDb.findContact(new1.areaCode, new1.phoneNumber); //Checks contacts
if (checkList == "Not found")
{
ViewData["SuccessMsg"] = "Error. Contact does not exist. Go to contacts page above."; //Throws an error if not found
}
else
{ //if found passes to success page
ViewData["Content"] = new1.textContent;
var name2 = newDb.GetName(new1.areaCode, new1.phoneNumber);
if (name2 != null)
{
foreach (var VARIABLE in name2)
{
ViewData["Receiver"] = VARIABLE;
}
}
return(View("Success")); // Returns success page
Logging lognew = new Logging(new1.textContent); // Logs messages
}
}
return(View(new1)); // Returns same page with inputed value if error
}
public void ContactsTest()
{
var controller = new PersonController();
var result = controller.Contacts() as ViewResult;
var data = result.ViewData.Model;
Assert.AreEqual(MockDB.getContacts(), data);
}
public async Task GetAsyncStringEmptyTest()
{
//Arrange
MockDB.Setup(m => m.StringGetAsync(It.IsAny <RedisKey>(), It.IsAny <CommandFlags>())).Returns(Task.FromResult(new RedisValue("")));
//Act
string actual = await RedisContext.GetAsync("variavel");
//Assert
Assert.IsTrue(string.IsNullOrWhiteSpace(actual));
}
public async Task GetAsyncObjectNullTest()
{
//Arrange
MockDB.Setup(m => m.StringGetAsync(It.IsAny <RedisKey>(), It.IsAny <CommandFlags>())).Returns(Task.FromResult(new RedisValue("")));
//Act
var actual = await RedisContext.GetAsync <Test>("variavel");
//Assert
Assert.IsTrue(actual is null);
}
public void GetObjectNullTest()
{
//Arrange
MockDB.Setup(m => m.StringGet(It.IsAny <RedisKey>(), It.IsAny <CommandFlags>())).Returns("");
//Act
var actual = RedisContext.Get <Test>("variavel");
//Assert
Assert.IsTrue(actual is null);
}
static void Main(string[] args)
{
ISolvrDB Db = new MockDB();
var dbResult = Db.GetLastPost();
Console.WriteLine("" + dbResult);
Console.ReadLine();
}
public async Task GetAsyncObjectTest()
{
//Arrange
var expected = JsonSerializer.Deserialize <Test>("{\"Teste\":\"Teste\"}");
MockDB.Setup(m => m.StringGetAsync(It.IsAny <RedisKey>(), It.IsAny <CommandFlags>())).Returns(Task.FromResult(new RedisValue("{\"Teste\":\"Teste\"}")));
//Act
var actual = await RedisContext.GetAsync <Test>("variavel");
//Assert
Assert.AreEqual(expected.Teste, actual.Teste);
}
public void GetStringTest()
{
//Arrange
string expected = "Teste";
MockDB.Setup(m => m.StringGet(It.IsAny <RedisKey>(), It.IsAny <CommandFlags>())).Returns("Teste");
//Act
string actual = RedisContext.Get("variavel");
//Assert
Assert.AreEqual(expected, actual);
}
public void GetObjectTest()
{
//Arrange
var expected = JsonSerializer.Deserialize <Test>("{\"Teste\":\"Teste\"}");
MockDB.Setup(m => m.StringGet(It.IsAny <RedisKey>(), It.IsAny <CommandFlags>())).Returns("{\"Teste\":\"Teste\"}");
//Act
var actual = RedisContext.Get <Test>("variavel");
//Assert
Assert.AreEqual(expected.Teste, actual.Teste);
}
public async Task GetAsyncStringTest()
{
//Arrange
string expected = "Teste";
MockDB.Setup(m => m.StringGetAsync(It.IsAny <RedisKey>(), It.IsAny <CommandFlags>())).Returns(Task.FromResult(new RedisValue("Teste")));
//Act
string actual = await RedisContext.GetAsync("variavel");
//Assert
Assert.AreEqual(expected, actual);
}
public async Task DeleteAsyncTest()
{
//Arrange
Dictionary <string, string> keys = new Dictionary <string, string>();
MockDB.Setup(m => m.KeyDeleteAsync(It.IsAny <RedisKey>(), CommandFlags.None)).Returns(Task.FromResult(true));
//Act
var actual = await RedisContext.DeleteAsync("Teste");
//Assert
Assert.IsTrue(actual);
}
public void DeleteTest()
{
//Arrange
Dictionary <string, string> keys = new Dictionary <string, string>();
MockDB.Setup(m => m.KeyDelete(It.IsAny <RedisKey>(), CommandFlags.None)).Returns(true);
//Act
var actual = RedisContext.Delete("Teste");
//Assert
Assert.IsTrue(actual);
}
public void SetDatabaseDefaultDatabaseTest()
{
//Arrange
int expected = -1;
Dictionary <string, string> keys = new Dictionary <string, string>();
MockDB.SetupGet(m => m.Database).Returns(-1);
//Act
RedisContext.SetDatabase();
var actual = RedisContext.Database.Database;
//Assert
Assert.AreEqual(expected, actual);
}
public void SetStringTest()
{
//Arrange
Dictionary <string, string> keys = new Dictionary <string, string>();
var expected = JsonSerializer.Deserialize <Test>("{\"Teste\":\"Teste\"}");
MockDB.Setup(m => m.StringSet(It.IsAny <RedisKey>(), It.IsAny <RedisValue>(), null, When.Always, CommandFlags.None))
.Callback <RedisKey, RedisValue, TimeSpan?, When, CommandFlags>((key, valeu, timeSpan, when, commandFlags) =>
{
keys.Add(key, valeu);
});
//Act
RedisContext.Set("Teste", "Teste");
//Assert
Assert.IsTrue(keys.Count > 0);
}
public async Task GetAllAsyncTest()
{
//Arrange
string expected = "Teste";
IEnumerable <RedisKey> keys = new List <RedisKey> {
new RedisKey("Teste")
};
MockServer.Setup(m => m.Keys(It.IsAny <int>(), It.IsAny <RedisValue>(), It.IsAny <int>(), It.IsAny <long>(), It.IsAny <int>(), It.IsAny <CommandFlags>()))
.Returns(keys);
MockDB.Setup(m => m.StringGetAsync(It.IsAny <RedisKey>(), It.IsAny <CommandFlags>())).Returns(Task.FromResult(new RedisValue("Teste")));
//Act
var actual = await RedisContext.GetAllAsync();
//Assert
Assert.IsTrue(actual.ContainsKey(expected));
}
public void Setup()
{
new YX.EventManager();
DB = new MockDB();
CardPool = new Pool <GameObject>();
var tmp = Instantiate(Resources.Load <GameObject>("view/card/TCard"));
var allocator = new GameObjectAllocator();
CardPool.SetTemplate(tmp, allocator);
DontDestroyOnLoad(allocator.CacheRoot);
LevelLoader = gameObject.AddComponent <LevelLoader>();
ProcessMgr = new ProcessManager();
//
_stateDict.Add(StateType.MainMenu, new MainMenuState());
_stateDict.Add(StateType.WorldMap, new WorldMapState());
_stateDict.Add(StateType.Battle, new BattleState());
}
public static async Task <IActionResult> RunGetAllSeasons(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "v1/seasons")] HttpRequest req, ILogger log, ExecutionContext context)
{
log.LogInformation("HomesteadApi/GetSeasonData HTTP trigger function processed a request.");
// Using this setup allows Environment Variables to be set via local settings in development, and App Settings in Azure
var config = StartupConfiguration.GetConfiguration(context);
//string name = req.Query["name"];
//string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
//dynamic data = JsonConvert.DeserializeObject(requestBody);
//name = name ?? data?.name;
List <SeasonData> seasonDatas = MockDB.GetSeasonData();
return(seasonDatas != null
? (ActionResult) new OkObjectResult(seasonDatas)
: new BadRequestObjectResult("Error. No Season Data Found."));
}
public void SetDatabaseDiferentDatabaseTest()
{
//Arrange
int expected = 0;
int _db = -1;
Dictionary <string, string> keys = new Dictionary <string, string>();
MockDB.Setup(m => m.Database).Returns(() => { return(_db); });
MockConn.Setup(m => m.GetDatabase(It.IsAny <int>(), It.IsAny <object>())).Returns <int, object>((db, asyncState) =>
{
_db = db;
return(MockDB.Object);
});
//Act
RedisContext.SetDatabase(0);
var actual = RedisContext.Database.Database;
//Assert
Assert.AreEqual(expected, actual);
}
public ActionResult SendSMS(SMS sms)
{
if (!ModelState.IsValid)
{
return(View(sms));
}
Person model = MockDB.getContacts()
.Where(p => p.AreaCode == sms.AreaCode && p.PhoneNumber == sms.PhoneNumber).FirstOrDefault();
// if person is found in list, load Send message page
if (model != null)
{
ViewBag.Message = sms.TextMessage;
// writing message log
Logger.Log(sms.TextMessage);
return(View(model));
}
// else: load error page
else
{
return(RedirectToAction("Error"));
}
}
public Server()
{
DB = MockDB.GetInstance();
}
private ccEntities initDB()
{
MockDB db = new MockDB();
List <MembershipUser> mem = db.MemUsers;
mem.Add(new MembershipUser()
{
Id = 0,
User = new User()
{
Id = 0,
UserName = "******",
RoleId = (int)FixedRoles.AgencyOfficer
},
LoweredUserName = "******"
});
mem.Add(new MembershipUser()
{
Id = 1,
User = new User()
{
Id = 1,
UserName = "******",
RoleId = (int)FixedRoles.Admin
},
LoweredUserName = "******"
});
mem.Add(new MembershipUser()
{
Id = 2,
User = new User()
{
Id = 2,
UserName = "******",
RoleId = (int)FixedRoles.AgencyUser
},
LoweredUserName = "******"
});
mem.Add(new MembershipUser()
{
Id = 3,
User = new User()
{
Id = 3,
UserName = "******",
RoleId = (int)FixedRoles.GlobalOfficer
},
LoweredUserName = "******"
});
mem.Add(new MembershipUser()
{
Id = 4,
User = new User()
{
Id = 4,
UserName = "******",
RoleId = (int)FixedRoles.RegionOfficer
},
LoweredUserName = "******"
});
mem.Add(new MembershipUser()
{
Id = 5,
User = new User()
{
Id = 5,
UserName = "******",
RoleId = (int)FixedRoles.Ser
},
LoweredUserName = "******"
});
return(db);
}
public IActionResult AddPermissions([FromBody] PermissionRequest request)
{
var data = MockDB.AddNewPermission(request.Module, request.Ability);
return(Ok(data));
}
// GET: Display list of contacts
public ActionResult Contacts()
{
var plist = MockDB.getContacts();
return(View(plist));
}
public AddStudentCommandHandler(MockDB mockDB)
{
this.mockDB = mockDB;
}
public StudentHandler(MockDB dB)
{
DB = dB;
}
public StudentByIdHandler(MockDB dB)
{
this.dB = dB;
}
public void Initialize()
{
_context = MockDB.cinema_DbEntities();
}
