public void Return_True_When_A_Value_Is_Successfully_Added()
{
// Arrange
const string cacheName = "SuperHeroesCache";
var cache = new InMemoryCache( cacheName );
var superman = new SuperHero { SuperHeroName = "Superman", RealFirstName = "Clark", RealLastName = "Kent" };
// Act
var valueAdded = cache.Add( superman.SuperHeroName, superman );
// Assert
Assert.True( valueAdded );
}
private static void Example6()
{
var superHero = new SuperHero();
superHero.Fly();
superHero.GodMode();
superHero.Stab();
IHero hero = superHero;
hero.Fly();
IAssassin assassin = superHero;
assassin.Stab();
IMarvelFeatures marvelFeatures = superHero;
marvelFeatures.GodMode();
}
public void Should_Call_The_DataRecordCall_Action_For_Each_Record_In_The_Result_Set()
{
// Arrange
const string sql = @"
DROP TEMPORARY TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId INT NOT NULL AUTO_INCREMENT,
SuperHeroName VARCHAR(120) NOT NULL,
PRIMARY KEY ( SuperHeroId )
);
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
// Act
var superHeroesTask = Sequelocity.GetDatabaseCommand( ConnectionStringsNames.MySqlConnectionString )
.SetCommandText( sql )
.ExecuteToMapAsync( record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue( 0 ).ToLong(),
SuperHeroName = record.GetValue( 1 ).ToString()
};
return obj;
} );
// Assert
Assert.IsInstanceOf<Task<List<SuperHero>>>(superHeroesTask);
Assert.That(superHeroesTask.Result.Count == 2);
}
public void Should_Call_The_DataRecordCall_Action_For_Each_Record_In_The_Result_Set()
{
// Arrange
const string sql = @"
DROP TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId serial not null,
SuperHeroName VARCHAR(120) NOT NULL,
PRIMARY KEY ( SuperHeroId )
);
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
// Act
var superHeroes = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.PostgreSQLConnectionString)
.SetCommandText(sql)
.ExecuteToMap(record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue(0).ToLong(),
SuperHeroName = record.GetValue(1).ToString()
};
return obj;
});
// Assert
Assert.That(superHeroes.Count == 2);
}
public void Should_Null_The_DbCommand_By_Default()
{
// Arrange
const string sql = @"
CREATE TABLE #SuperHero
(
SuperHeroId INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
SuperHeroName NVARCHAR(120) NOT NULL
);
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM #SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommand( ConnectionStringsNames.SqlServerConnectionString )
.SetCommandText( sql );
// Act
var superHeroes = databaseCommand.ExecuteToMap( record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue( 0 ).ToLong(),
SuperHeroName = record.GetValue( 1 ).ToString()
};
return obj;
} );
// Assert
Assert.IsNull( databaseCommand.DbCommand );
}
public void Should_Call_The_DataRecordCall_Action_For_Each_Record_In_The_Result_Set()
{
// Arrange
const string sql = @"
CREATE TABLE #SuperHero
(
SuperHeroId INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
SuperHeroName NVARCHAR(120) NOT NULL
);
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM #SuperHero;
";
// Act
var superHeroes = Sequelocity.GetDatabaseCommand( ConnectionStringsNames.SqlServerConnectionString )
.SetCommandText( sql )
.ExecuteToMap( record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue( 0 ).ToLong(),
SuperHeroName = record.GetValue( 1 ).ToString()
};
return obj;
} );
// Assert
Assert.That( superHeroes.Count == 2 );
}
public ActionResult Edit(int id, SuperHero hero)
{
var newhero = db.SuperHeroes.Where(h => h.Id == id).FirstOrDefault();
try
{
// TODO: Add update logic here
db.SuperHeroes.Remove(newhero);
db.SaveChanges();
newhero.Name = hero.Name;
newhero.AlterEgo = hero.AlterEgo;
newhero.PrimarySuperheroAbility = hero.PrimarySuperheroAbility;
newhero.SecondarySuperheroAbility = hero.SecondarySuperheroAbility;
newhero.Catchpharse = hero.Catchpharse;
db.SuperHeroes.Add(newhero);
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public IActionResult PutSuperHero([FromRoute] int id, [FromBody] SuperHero superHero)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != superHero.Id)
{
return(BadRequest());
}
try
{
_superHeroService.Update(id, superHero);
}
catch (Exception ex)
{
throw ex;
}
return(NoContent());
}
public void Research_WhenHero1AlwaysWinsInTheFightAlgorithm_Hero1ShouldWin100PercentOfTheTime()
{
var hero1 = new SuperHero {
HeroName = "Brent"
};
var heroList = new StaticHeroService().GetHeroes().ToList();
heroList.Add(hero1);
var mockFightAlgorithm = new Mock <IFightAlgorithm>();
mockFightAlgorithm.Setup(a => a.Fight(It.IsAny <SuperHero>(), It.IsAny <SuperHero>(), It.IsAny <IArena>())).Returns(hero1);
var mockHeroFactory = new Mock <IHeroFactory>();
mockHeroFactory.Setup(f => f.GetAllHeroes()).Returns(heroList);
var mockArena = new Mock <IArena>();
var analyzer = new BattleAnalyzer(mockFightAlgorithm.Object, mockArena.Object, mockHeroFactory.Object);
var winPercentage = analyzer.Reserch("Brent");
Assert.AreEqual(1, winPercentage);
}
public async Task <IActionResult> AddHeroAsync(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = "superhero/{heroId}/add")] HttpRequest req,
int heroId,
CancellationToken cts,
ILogger log)
{
log.LogInformation("C# HTTP POST/post trigger function processed a request.");
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
var data = JsonConvert.DeserializeObject <SuperHero>(requestBody);
var superHero = new SuperHero
{
Id = heroId,
Name = data.Name,
Power = data.Power
};
var entity = await _context.SuperHeroes.AddAsync(superHero, cts);
await _context.SaveChangesAsync(cts);
return(new OkObjectResult(JsonConvert.SerializeObject(entity.Entity)));
}
public void generateRandomPowersTestMethod()
{
/*
* //Arrange
* SuperHero superhero = new SuperHero("Jack");
* Random ram = new Random();
*
* int x = ram.Next(0, 6);//0,1,2,3,4,5
* //Act
* bool check = (x == 0 || x == 1 || x == 2 || x == 3 || x == 4 || x == 5);
* bool expectedFail = (x == 6);
*
* //Assert
* Assert.IsTrue(check);// Pass!! This test shows that x is between 0 and 5;
*/
//Arrange
SuperHero super = new SuperHero("Tom");
bool hasDuplicatePowers = false;
//Act
if (super.SuperPowers[0] == super.SuperPowers[1])
{
hasDuplicatePowers = true;
}
else if (super.SuperPowers[1] == super.SuperPowers[2])
{
hasDuplicatePowers = true;
}
else if (super.SuperPowers[0] == super.SuperPowers[2])
{
hasDuplicatePowers = true;
}
//Assert
Assert.IsTrue(!hasDuplicatePowers);//Pass!!
}
public void Should_Null_The_DbCommand_By_Default()
{
// Arrange
const string sql = @"
CREATE TABLE IF NOT EXISTS SuperHero
(
SuperHeroId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
SuperHeroName NVARCHAR(120) NOT NULL,
UNIQUE(SuperHeroName)
);
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Superman' );
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommandForSQLite( ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString )
.SetCommandText( sql );
// Act
databaseCommand.ExecuteToMapAsync( record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue( 0 ).ToLong(),
SuperHeroName = record.GetValue( 1 ).ToString()
};
return obj;
} )
.Wait(); // Block until the task completes.
// Assert
Assert.IsNull( databaseCommand.DbCommand );
}
public void Should_Call_The_DataRecordCall_Action_For_Each_Record_In_The_Result_Set()
{
// Arrange
const string sql = @"
CREATE TABLE IF NOT EXISTS SuperHero
(
SuperHeroId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
SuperHeroName NVARCHAR(120) NOT NULL,
UNIQUE(SuperHeroName)
);
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Superman' );
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
// Act
var superHeroesTask = Sequelocity.GetDatabaseCommandForSQLite(ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString)
.SetCommandText(sql)
.ExecuteToMapAsync(record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue(0).ToLong(),
SuperHeroName = record.GetValue(1).ToString()
};
return(obj);
});
// Assert
Assert.IsInstanceOf <Task <List <SuperHero> > >(superHeroesTask);
Assert.That(superHeroesTask.Result.Count == 2);
}
static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.DarkGreen;
//Console.WriteLine("Hello World!");
Console.WriteLine("Type in a superhero's name to see his nickname: ");
string userValue = Console.ReadLine();
SuperHero myValue = SuperHero.Superman;
if (Enum.TryParse <SuperHero>(userValue, true, out myValue))
{
switch (myValue)
{
case SuperHero.Batman:
Console.WriteLine("Caped Crusader");
break;
case SuperHero.Superman:
Console.WriteLine("Man of Steel");
break;
case SuperHero.GreenLantern:
Console.WriteLine("Emerald Knight");
break;
default:
break;
}
}
else
{
Console.WriteLine("Wrong");
}
Console.ReadLine();
}
public void Should_Null_The_DbCommand_By_Default()
{
// Arrange
const string sql = @"
CREATE TABLE IF NOT EXISTS SuperHero
(
SuperHeroId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
SuperHeroName NVARCHAR(120) NOT NULL,
UNIQUE(SuperHeroName)
);
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Superman' );
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommandForSQLite(ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString)
.SetCommandText(sql);
// Act
databaseCommand.ExecuteToMapAsync(record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue(0).ToLong(),
SuperHeroName = record.GetValue(1).ToString()
};
return(obj);
})
.Wait(); // Block until the task completes.
// Assert
Assert.IsNull(databaseCommand.DbCommand);
}
public void Should_Call_The_DataRecordCall_Action_For_Each_Record_In_The_Result_Set()
{
// Arrange
const string sql = @"
CREATE TABLE IF NOT EXISTS SuperHero
(
SuperHeroId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
SuperHeroName NVARCHAR(120) NOT NULL,
UNIQUE(SuperHeroName)
);
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Superman' );
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
// Act
var superHeroesTask = Sequelocity.GetDatabaseCommandForSQLite( ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString )
.SetCommandText( sql )
.ExecuteToMapAsync( record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue( 0 ).ToLong(),
SuperHeroName = record.GetValue( 1 ).ToString()
};
return obj;
} );
// Assert
Assert.IsInstanceOf<Task<List<SuperHero>>>(superHeroesTask);
Assert.That( superHeroesTask.Result.Count == 2 );
}
public void Should_Call_The_DatabaseCommandPostExecuteEventHandler()
{
// Arrange
bool wasPostExecuteEventHandlerCalled = false;
Sequelocity.ConfigurationSettings.EventHandlers.DatabaseCommandPostExecuteEventHandlers.Add(command => wasPostExecuteEventHandlerCalled = true);
// Act
var superHeroes = Sequelocity.GetDatabaseCommandForSQLite(ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString)
.SetCommandText("SELECT 1 as SuperHeroId, 'Superman' as SuperHeroName")
.ExecuteToMap(record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue(0).ToLong(),
SuperHeroName = record.GetValue(1).ToString()
};
return(obj);
});
// Assert
Assert.IsTrue(wasPostExecuteEventHandlerCalled);
}
public Superpeople ParseSuperHero(SuperHero hero)
{
if (hero.SuperPowers != null)
{
return(new Superpeople()
{
Realname = hero.RealName,
Workname = hero.Alias,
Hideout = hero.HideOut,
Powers = ParseSuperPower(hero.SuperPowers),
Chartype = 1
});
}
else
{
return(new Superpeople()
{
Realname = hero.RealName,
Workname = hero.Alias,
Hideout = hero.HideOut,
Chartype = 1
});
}
}
public ActionResult uploadImage(int?id, HttpPostedFileBase file)
{
SuperHero hero = db.SuperHeroes.Where(x => x.id == id).FirstOrDefault();
try
{
if (ModelState.IsValid)
{
if (file != null)
{
file.SaveAs(HttpContext.Server.MapPath("/Images/")
+ file.FileName);
hero.imgPath = file.FileName;
}
db.SaveChanges();
}
}
catch (Exception E)
{
return(RedirectToAction("Edit/" + id.ToString()));
}
return(RedirectToAction("Edit/" + id.ToString()));
}
/*
* This is the driver class == basically where the methods are tested, and given values, to be shown in the Console window
*@class program
*/
static void Main(string[] args)
{
//Assignment01
//// this shows a hero having the fight method = true
//Console.WriteLine();
//Hero CaptainComp = new Hero("CaptainComp "); // same as displaying says hello as new ("")
//CaptainComp.Strength = 10;
//CaptainComp.Speed = 65;
//CaptainComp.Health = 100;
//CaptainComp.Name = "CaptainComp";
//CaptainComp.Show();
//CaptainComp.Fight(true);
//Console.WriteLine();
//Console.WriteLine("");
//// this shows fight = false
//Console.WriteLine();
//Hero CaptainSeaSharp = new Hero("CaptainSeaSharp "); // same as displaying says hello as new ("")
//CaptainSeaSharp.Strength = 2;
//CaptainSeaSharp.Speed = 15;
//CaptainSeaSharp.Health = 100;
//CaptainSeaSharp.Name = "CaptainSeaSharp";
//CaptainSeaSharp.Show();
//CaptainSeaSharp.Fight(false);
//Assignment 02
SuperHero SuperComp = new SuperHero("Super Comp");
SuperComp.Show();
SuperComp.ShowPowers();
SuperComp.Health = 100;
SuperComp.Strength = 15;
SuperComp.Speed = 25;
SuperComp.Fight(true);
}
public void Should_Keep_The_Database_Connection_Open_If_keepConnectionOpen_Parameter_Was_True()
{
// Arrange
const string sql = @"
DROP TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId serial not null,
SuperHeroName VARCHAR(120) NOT NULL,
PRIMARY KEY ( SuperHeroId )
);
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.PostgreSQLConnectionString)
.SetCommandText(sql);
// Act
var superHeroes = databaseCommand.ExecuteToMap(record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue(0).ToLong(),
SuperHeroName = record.GetValue(1).ToString()
};
return obj;
}, true);
// Assert
Assert.That(databaseCommand.DbCommand.Connection.State == ConnectionState.Open);
// Cleanup
databaseCommand.Dispose();
}
// GET: SuperHero/Delete/5
public ActionResult Delete(int id)
{
SuperHero superHero = context.Supers.Where(i => i.Id == id).Single();
return(View(superHero));
}
abstract override public void setSuperHero(SuperHero superHero);
virtual public void setSuperHero(SuperHero superHero)
{
}
public async Task AddSuperHeroAsync(SuperHero superHero)
{
await _context.SuperHeroes.AddAsync(superHero);
await _context.SaveChangesAsync();
}
public ActionResult Edit(int id)
{
SuperHero superHero = db.SuperHeroe.Find(id);
return(View(superHero));
}
// GET: Superheroes/Edit/5
public ActionResult Edit(int id)
{
SuperHero superHero = context.superHeroes.Where(c => c.id == id).Single();
return(View(superHero));
}
public void Should_Call_The_DatabaseCommandUnhandledExceptionEventHandler()
{
// Arrange
bool wasUnhandledExceptionEventHandlerCalled = false;
Sequelocity.ConfigurationSettings.EventHandlers.DatabaseCommandUnhandledExceptionEventHandlers.Add((exception, command) =>
{
wasUnhandledExceptionEventHandlerCalled = true;
});
// Act
TestDelegate action = () => Sequelocity.GetDatabaseCommand(ConnectionStringsNames.PostgreSQLConnectionString)
.SetCommandText("asdf;lkj")
.ExecuteToMap(record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue(0).ToLong(),
SuperHeroName = record.GetValue(1).ToString()
};
return obj;
});
// Assert
Assert.Throws<global::Npgsql.NpgsqlException>(action);
Assert.IsTrue(wasUnhandledExceptionEventHandlerCalled);
}
public void Should_Call_The_DatabaseCommandUnhandledExceptionEventHandler()
{
// Arrange
bool wasUnhandledExceptionEventHandlerCalled = false;
Sequelocity.ConfigurationSettings.EventHandlers.DatabaseCommandUnhandledExceptionEventHandlers.Add( ( exception, command ) =>
{
wasUnhandledExceptionEventHandlerCalled = true;
} );
// Act
TestDelegate action = async () => await Sequelocity.GetDatabaseCommandForSQLite( ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString )
.SetCommandText( "asdf;lkj" )
.ExecuteToMapAsync( record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue( 0 ).ToLong(),
SuperHeroName = record.GetValue( 1 ).ToString()
};
return obj;
} );
// Assert
Assert.Throws<System.Data.SQLite.SQLiteException>( action );
Assert.IsTrue( wasUnhandledExceptionEventHandlerCalled );
}
public override void setSuperHero(SuperHero superHero){
this.superHero = superHero;
}
virtual public void setSuperHero(SuperHero superHero){}
public void Should_Call_The_DatabaseCommandPostExecuteEventHandler()
{
// Arrange
bool wasPostExecuteEventHandlerCalled = false;
Sequelocity.ConfigurationSettings.EventHandlers.DatabaseCommandPostExecuteEventHandlers.Add(command => wasPostExecuteEventHandlerCalled = true);
// Act
var superHeroes = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.PostgreSQLConnectionString)
.SetCommandText("SELECT 1 as SuperHeroId, 'Superman' as SuperHeroName")
.ExecuteToMap(record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue(0).ToLong(),
SuperHeroName = record.GetValue(1).ToString()
};
return obj;
});
// Assert
Assert.IsTrue(wasPostExecuteEventHandlerCalled);
}
public void Should_Call_The_DatabaseCommandPreExecuteEventHandler()
{
// Arrange
bool wasPreExecuteEventHandlerCalled = false;
Sequelocity.ConfigurationSettings.EventHandlers.DatabaseCommandPreExecuteEventHandlers.Add( command => wasPreExecuteEventHandlerCalled = true );
// Act
Sequelocity.GetDatabaseCommand( ConnectionStringsNames.MySqlConnectionString )
.SetCommandText( "SELECT 1 as SuperHeroId, 'Superman' as SuperHeroName" )
.ExecuteToMapAsync( record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue( 0 ).ToLong(),
SuperHeroName = record.GetValue( 1 ).ToString()
};
return obj;
} )
.Wait(); // Block until the task completes.
// Assert
Assert.IsTrue( wasPreExecuteEventHandlerCalled );
}
public void Should_Null_The_DbCommand_By_Default()
{
// Arrange
const string sql = @"
DROP TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId serial not null,
SuperHeroName VARCHAR(120) NOT NULL,
PRIMARY KEY ( SuperHeroId )
);
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommand(ConnectionStringsNames.PostgreSQLConnectionString)
.SetCommandText(sql);
// Act
var superHeroes = databaseCommand.ExecuteToMap(record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue(0).ToLong(),
SuperHeroName = record.GetValue(1).ToString()
};
return obj;
});
// Assert
Assert.IsNull(databaseCommand.DbCommand);
}
// GET: SuperHero/Delete/5
public ActionResult Delete()
{
SuperHero superHero = new SuperHero();
return(View());
}
public ActionResult Details(int id = 0)
{
SuperHero superHero = db.SuperHeroe.Find(id);
return(View(superHero));
}
// GET: SuperHero/Edit/5
public ActionResult Edit(int id)
{
SuperHero superHero = context.People.Where(e => e.Id == id).FirstOrDefault();
return(View(superHero));
}
public ActionResult Delete(int?id)
{
SuperHero superHero = db.SuperHeroe.Find(id);
return(View(superHero));
}
// GET: SuperHero/Details/5
public ActionResult Details(int id)
{
SuperHero superHero = new SuperHero();
return(View());
}
public ActionResult Delete(int id)
{
SuperHero deleteSuperHero = db.SuperHeroes.Find(id);
return(View(deleteSuperHero));
}
public void Should_Keep_The_Database_Connection_Open_If_keepConnectionOpen_Parameter_Was_True()
{
// Arrange
const string sql = @"
CREATE TABLE #SuperHero
(
SuperHeroId INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
SuperHeroName NVARCHAR(120) NOT NULL
);
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM #SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommand( ConnectionStringsNames.SqlServerConnectionString )
.SetCommandText( sql );
// Act
var superHeroes = databaseCommand.ExecuteToMap( record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue( 0 ).ToLong(),
SuperHeroName = record.GetValue( 1 ).ToString()
};
return obj;
}, true );
// Assert
Assert.That( databaseCommand.DbCommand.Connection.State == ConnectionState.Open );
// Cleanup
databaseCommand.Dispose();
}
public ActionResult Create([Bind(Include = "Id,Name,AlterEgo,PrimaryAbility,SecondaryAbility,CatchPhrase")] SuperHero superHero)
{
db.SuperHero.Add(superHero);
db.SaveChanges();
return(RedirectToAction("Read"));
}
// GET: SuperHero/Edit/5
public ActionResult Edit(int id)
{
SuperHero dbSuperHero = context.Supers.Where(s => s.Id == id).Single();
return(View(dbSuperHero));
}
public void AddHero(SuperHero newHero)
{
//Add some business logic here
repo.AddAHeroAsync(newHero);
}
public void ExecuteToMap_Example()
{
// Arrange
const string sql = @"
CREATE TABLE #SuperHero
(
SuperHeroId INT NOT NULL IDENTITY(1,1) PRIMARY KEY,
SuperHeroName NVARCHAR(120) NOT NULL
);
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO #SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM #SuperHero;";
// Act
List<SuperHero> superHeroes = Sequelocity.GetDatabaseCommand( ConnectionStringsNames.SqlServerConnectionString )
.SetCommandText( sql )
.ExecuteToMap( record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue( 0 ).ToLong(),
SuperHeroName = record.GetValue( 1 ).ToString()
};
return obj;
} );
// Assert
Assert.That( superHeroes.Count == 2 );
Assert.That( superHeroes[0].SuperHeroId == 1 );
Assert.That( superHeroes[0].SuperHeroName == "Superman" );
Assert.That( superHeroes[1].SuperHeroId == 2 );
Assert.That( superHeroes[1].SuperHeroName == "Batman" );
}
// GET: SuperHero/Edit/5
public ActionResult Edit()
{
SuperHero superHero = new SuperHero();
return(View());
}
// GET: SuperHero/Details/5
public ActionResult Details(int id)
{
SuperHero SuperHeroEdit = context.Supers.Where(s => s.Id == id).Single();
return(View(SuperHeroEdit));
}
// GET: SuperHero/Create
public ActionResult Create()
{
SuperHero superhero = new SuperHero();
return(View(superhero));
}
public void Should_Null_The_DbCommand_By_Default()
{
// Arrange
const string sql = @"
DROP TEMPORARY TABLE IF EXISTS SuperHero;
CREATE TEMPORARY TABLE SuperHero
(
SuperHeroId INT NOT NULL AUTO_INCREMENT,
SuperHeroName VARCHAR(120) NOT NULL,
PRIMARY KEY ( SuperHeroId )
);
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Superman' );
INSERT INTO SuperHero ( SuperHeroName )
VALUES ( 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommand( ConnectionStringsNames.MySqlConnectionString )
.SetCommandText( sql );
// Act
databaseCommand.ExecuteToMapAsync( record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue( 0 ).ToLong(),
SuperHeroName = record.GetValue( 1 ).ToString()
};
return obj;
} )
.Wait(); // Block until the task completes.
// Assert
Assert.IsNull( databaseCommand.DbCommand );
}
// GET: SuperHero/Delete/5
public ActionResult Delete(int id)
{
SuperHero superHero = context.People.Find(id);
return(View(superHero));
}
public void Should_Keep_The_Database_Connection_Open_If_keepConnectionOpen_Parameter_Was_True()
{
// Arrange
const string sql = @"
CREATE TABLE IF NOT EXISTS SuperHero
(
SuperHeroId INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
SuperHeroName NVARCHAR(120) NOT NULL,
UNIQUE(SuperHeroName)
);
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Superman' );
INSERT OR IGNORE INTO SuperHero VALUES ( NULL, 'Batman' );
SELECT SuperHeroId,
SuperHeroName
FROM SuperHero;
";
var databaseCommand = Sequelocity.GetDatabaseCommandForSQLite( ConnectionStringsNames.SqliteInMemoryDatabaseConnectionString )
.SetCommandText( sql );
// Act
var superHeroes = databaseCommand.ExecuteToMap( record =>
{
var obj = new SuperHero
{
SuperHeroId = record.GetValue( 0 ).ToLong(),
SuperHeroName = record.GetValue( 1 ).ToString()
};
return obj;
}, true );
// Assert
Assert.That( databaseCommand.DbCommand.Connection.State == ConnectionState.Open );
// Cleanup
databaseCommand.Dispose();
}
