public void CreateUserWithInvalidNameTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
string targetUser = "******";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 7, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
User u = new User();
u.Id = targetUser;
u.FullName = "The New Guy";
u.Password = "******";
u.EmailAddress = "*****@*****.**";
con.UserName = targetUser;
connected = con.Connect(null);
Assert.IsTrue(connected);
try
{
User newGuy = rep.CreateUser(u);
}
catch (P4Exception e)
{
Assert.AreEqual(822155268, e.ErrorCode, "Invalid user (P4USER) or client (P4CLIENT) name.\nInitial dash character not allowed in '%targetUser'.\n");
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void UpdateUserNameTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "Alex_space";
string newTargetUserName = "******";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
string targetUser = "******";
if (i > 0)
{
targetUser = "******";
}
p4d = Utilities.DeployP4TestServer(TestDir, 7, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
User u = rep.GetUser(targetUser);
Assert.IsNotNull(u);
u.FullName = newTargetUserName;
try
{
Options uFlags = new Options(UserCmdFlags.Force);
User updatedUser = rep.UpdateUser(u, uFlags);
}
catch (P4Exception e)
{
Assert.AreEqual(805705769, e.ErrorCode, "You don't have permission for this operation.\n");
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public static void CleanupTest(string testDir)
{
foreach (var proc in procsToCleanup)
{
Utilities.RemoveTestServer(proc, testDir);
}
}
public void SubmitOptionsNoneTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
Changelist change = new Changelist(5, true);
change.initialize(con);
SubmitCmdOptions submitOptions = new SubmitCmdOptions(Perforce.P4.SubmitFilesCmdFlags.None, 5, null, null, null);
SubmitResults sr = change.Submit(submitOptions);
FileSpec fs = FileSpec.DepotSpec("//depot/MyCode/NewFile.txt");
Options ops = new Options();
IList <FileMetaData> actual = rep.GetFileMetaData(ops, fs);
FileAction expected = FileAction.None;
Assert.AreEqual(expected, actual[0].Action);
Assert.IsNotNull(sr);
Assert.AreEqual(1, sr.Files.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void CreateIncompleteUserTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
string targetUser = "******";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 7, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
User u = new User();
u.Id = targetUser;
u.Password = "******";
u.EmailAddress = "*****@*****.**";
con.UserName = targetUser;
connected = con.Connect(null);
Assert.IsTrue(connected);
try
{
User newGuy = rep.CreateUser(u);
}
catch (P4Exception e)
{
Assert.AreEqual(822153261, e.ErrorCode, "Error in user specification.\nMissing required field 'FullName'.\n");
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void DeleteJobTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
string targetJob = "job000002";
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 11, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Job u = new Job();
u.Id = targetJob;
IList <Job> u2 = rep.GetJobs(new Options(JobsCmdFlags.LongDescriptions, null, 5));
Assert.IsNotNull(u2);
Assert.AreEqual(3, u2.Count);
rep.DeleteJob(u, null);
u2 = rep.GetJobs(new Options(JobsCmdFlags.LongDescriptions, null, 5));
Assert.IsNotNull(u2);
Assert.AreEqual(2, u2.Count);
u2 = rep.GetJobs(new Options(JobsCmdFlags.IncludeIntegratedFixes, null, 5));
Assert.IsNotNull(u2);
Assert.AreEqual(2, u2.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void SubmitShelvedFromChangelist()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
Changelist change = new Changelist(5, true);
change.initialize(con);
// shelve the files in changelist 5
con.Client.ShelveFiles(new ShelveFilesCmdOptions(ShelveFilesCmdFlags.None,
null, change.Id));
// revert the checked out file that was shelved
FileSpec file = new FileSpec(new DepotPath("//..."), null, null, null);
con.Client.RevertFiles(new RevertCmdOptions(RevertFilesCmdFlags.None, change.Id),
file);
// submit the shelved file
SubmitCmdOptions submitOptions = new
SubmitCmdOptions(Perforce.P4.SubmitFilesCmdFlags.SubmitShelved,
5, null, null, null);
change.Submit(submitOptions);
P4CommandResult last = rep.Connection.LastResults;
Assert.IsTrue(last.Success);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void GetLabelsWithOptionsTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
// TODO update test with Edge Server installation
Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
LabelsCmdOptions opts = new LabelsCmdOptions(LabelsCmdFlags.None,
null, null, 50, null, null);
IList <Label> labels = rep.GetLabels(opts);
Assert.AreEqual("Created by admin.\n", labels[0].Description);
opts = new LabelsCmdOptions(LabelsCmdFlags.Unloaded,
null, null, 50, null, null);
labels = rep.GetLabels(opts);
Assert.IsNull(labels);
opts = new LabelsCmdOptions(LabelsCmdFlags.All,
null, null, 50, null, null);
labels = rep.GetLabels(opts);
Assert.AreEqual("Created by admin.\n", labels[0].Description);
opts = new LabelsCmdOptions(LabelsCmdFlags.None,
null, null, 50, null, "1666-master");
labels = rep.GetLabels(opts);
Assert.IsNull(labels);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void GetBranchSpecTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
string targetBranchSpec = "MyCode->MyCode2";
BranchSpec b = rep.GetBranchSpec(targetBranchSpec);
Assert.IsNotNull(b);
Assert.AreEqual(targetBranchSpec, b.Id);
BranchSpec b1 = rep.GetBranchSpec("StreamBranchMapWithD3", "//flow/D3", null, null);
Assert.IsNotNull(b1);
Assert.IsTrue(b1.ViewMap[0].Left.Path.Contains("flow/D3/..."));
BranchSpec b2 = rep.GetBranchSpec("StreamBranchMapWithD3OtherParent", "//flow/D3", "//flow/D2", null);
Assert.IsNotNull(b2);
Assert.AreEqual(b2.ViewMap.Count, 6);
Assert.IsTrue(b2.ViewMap[0].Type.Equals(MapType.Exclude));
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void DeleteDepotWithFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
String depotName = "flow";
Depot depot = rep.GetDepot(depotName, null);
Assert.IsNotNull(depot);
try
{
rep.DeleteDepot(depot, null);
}
catch (P4Exception e)
{
Assert.AreEqual(822417475, e.ErrorCode,
"Depot flow isn't empty. To delete a depot, all file revisions must be removed "
+ "and all lazy copy references from other depots must be severed. Use 'p4 obliterate'"
+ "or 'p4 snap' to break file linkages from other depots, then clear this depot with "
+ "'p4 obliteror 'p4 snap' to break file linkages from other depots, then clear this depot "
+ "with 'p4 obliterate', then retry the deletion.");
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void UpdateSubmittedChangelistTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 7, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Changelist c = rep.GetChangelist(12);
c.Description += "\n\tModified!";
rep.UpdateSubmittedChangelist(c, null);
Changelist d = rep.GetChangelist(12);
Assert.IsTrue(d.Description.Contains("Modified!"));
// on the non-unicode server edit the description
// of Alex's changelist 8 as an admin
if (!unicode)
{
c = rep.GetChangelist(8);
c.Description += "\n\tModified!";
Options opts = new Options();
opts["-f"] = null;
rep.UpdateSubmittedChangelist(c, opts);
d = rep.GetChangelist(8);
Assert.IsTrue(d.Description.Contains("Modified!"));
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void DeleteDepotTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Depot d = new Depot();
d.Id = "NewDepot";
d.Description = "created by perforce";
d.Owner = "admin";
d.Type = DepotType.Local;
d.Map = "NewDepot/...";
d.StreamDepth = "//NewDepot/1";
Depot newDepot = rep.CreateDepot(d, null);
Assert.IsNotNull(newDepot);
rep.DeleteDepot(newDepot, null);
IList <Depot> dlist = rep.GetDepots();
Assert.IsFalse(dlist.Contains(newDepot));
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void InvalidLargeChangelistTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
// Assign changelist the maximum 32 bit integer
Changelist change = new Changelist(2147483647, true);
try
{
change.initialize(con);
}
catch (P4Exception e)
{
Assert.AreEqual(822220826, e.ErrorCode,
"Changelist should fail with error, \"Change 2147483647 unknown\", instead got " + e.Message);
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void CreateUserTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
string targetUser = "******";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 7, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
User u = new User();
u.Id = targetUser;
u.FullName = "The New Guy";
u.Password = "******";
u.EmailAddress = "*****@*****.**";
con.UserName = targetUser;
connected = con.Connect(null);
Assert.IsTrue(connected);
User newGuy = rep.CreateUser(u);
Assert.IsNotNull(newGuy);
Assert.AreEqual(targetUser, newGuy.Id);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void RshConnectionTest()
{
bool unicode = false;
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
var p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
Server server = new Server(new ServerAddress("localhost:6666"));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
uint cmdID = 7;
string[] args = new string[] { "stop" };
Assert.IsTrue(con.getP4Server().RunCommand("admin", cmdID, false, args, args.Length));
logger.Debug("Stopped launched server");
}
string uri = Utilities.TestRshServerPort(TestDir, unicode);
server = new Server(new ServerAddress(uri));
rep = new Repository(server);
logger.Debug("Created new server");
try
{
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
logger.Debug("About to connect");
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
logger.Debug("Connected");
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fs = new FileSpec(new DepotPath("//depot/MyCode/ReadMe.txt"), null);
rep.Connection.Client.EditFiles(null, fs);
logger.Debug("File edited");
}
} finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
}
public void FixJobsTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Changelist change = new Changelist(9, true);
change.initialize(con);
Job job = new Job();
job.Id = "job000001";
Options opt = new Options(FixJobsCmdFlags.None, -1, null);
IList <Fix> fixes = change.FixJobs(null, job);
Assert.IsNotNull(fixes);
Assert.AreEqual(1, fixes.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void CreateInvalidPathDepotTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Depot d = new Depot();
d.Id = "NewDepot";
d.Description = "created by perforce";
d.Owner = "admin";
d.Type = DepotType.Stream;
d.Map = "123";
try
{
Depot newDepot = rep.CreateDepot(d, null);
}
catch (P4Exception e)
{
Assert.AreEqual(822153266, e.ErrorCode, "Error in depot specification. "
+ "Map entry '123' must have only 1 wildcard which must be a trailing '/...' or '\\...'.");
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void DeleteNonExistentUserTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
string targetUser = "******";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 7, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
User u = new User();
u.Id = targetUser;
Options uFlags = new Options(UserCmdFlags.Force);
try
{
rep.DeleteUser(u, uFlags);
}
catch (P4Exception e)
{
Assert.AreEqual(822221158, e.ErrorCode, ("User %targetUser does not exist\n"));
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void GetChangelistTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Changelist c = rep.GetChangelist(5, null);
Assert.IsNotNull(c);
Assert.AreEqual("admin", c.OwnerName);
Assert.AreEqual(c.Files.Count, 1);
Assert.AreEqual(c.Jobs.Count, 1);
Assert.IsTrue(c.Files[0].DepotPath.Path.Contains("//depot/MyCode/NewFile.txt"));
if (unicode == false)
{
c = rep.GetChangelist(4, null);
Assert.AreEqual("admin", c.OwnerName);
Assert.AreEqual(c.Files.Count, 2);
Assert.AreEqual(c.Jobs.Count, 1);
Assert.IsTrue(c.Files[0].DepotPath.Path.Contains("//depot/TheirCode/ReadMe.txt"));
Assert.AreEqual(c.Files[0].Digest, "C7DECE3DB80A73F3F53AF4BCF6AC0576");
Assert.AreEqual(c.Files[0].FileSize, 30);
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void CreateExtraSpecDepotTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Depot d = new Depot();
d.Id = "NewDepot";
d.Description = "created by perforce";
d.Owner = "admin";
d.Type = DepotType.Spec;//.Local;
d.Map = "123";
d.StreamDepth = "//NewDepot/1";
try
{
Depot newDepot = rep.CreateDepot(d, null);
}
catch (P4Exception e)
{
Assert.AreEqual(839064437, e.ErrorCode, e.Message);
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void GetLabelsPreServerIDTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
// tests to ensure old labels options work, prior
// to ServerID argument
Options opts = new Options(LabelsCmdFlags.None, null, null,
50, null);
IList <Label> labels = rep.GetLabels(opts);
Assert.IsNotNull(labels);
Assert.AreEqual(1, labels.Count);
LabelsCmdOptions opts2 = new LabelsCmdOptions(LabelsCmdFlags.None, null, null,
50, null);
labels = rep.GetLabels(opts2);
Assert.IsNotNull(labels);
Assert.AreEqual(1, labels.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for UpdateLabel
///</summary>
public void UpdateLabelTestjob096467(bool unicode)
{
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
string targetLabel = "admin_label";
Label l = rep.GetLabel(targetLabel);
// change the viewmap to have an exclusionary line
ViewMap vm = l.ViewMap;
MapEntry original = vm[0];
MapEntry newExclude = new MapEntry(MapType.Exclude, original.Left, original.Right);
l.ViewMap.Remove(original);
l.ViewMap.Add(newExclude);
l = rep.UpdateLabel(l);
// now update the label without any changes, to
// confirm that the exclusionary line does not break
// the attempted update
l = rep.GetLabel(targetLabel);
l = rep.UpdateLabel(l);
Assert.IsNotNull(l);
Assert.AreEqual(targetLabel, l.Id);
Assert.AreEqual(l.ViewMap.Count, 1);
Assert.IsTrue(l.ViewMap[0].Type.Equals(MapType.Exclude));
Assert.IsTrue(l.ViewMap[0].Left.Path.Equals("//depot/..."));
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
}
public void UpdateGroupWithAdminFlagTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
string targetGroup = "everyone";
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Group newGuy = rep.GetGroup(targetGroup);
Assert.IsNotNull(newGuy);
newGuy.UserNames.Add("Alice");
newGuy.UserNames.Add("Alex");
try
{
Group u2 = rep.CreateGroup(newGuy, new Options(GroupCmdFlags.AdminAdd));
}
catch (P4Exception e)
{
Assert.AreEqual(822090446, e.ErrorCode, "Error in group specification.\nNo permission to modify existing group everyone.\n");
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void DeleteJobWithInvalidOptionsTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
string targetJob = "job000001";
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 11, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
IList <Job> u2 = rep.GetJobs(new Options(JobsCmdFlags.LongDescriptions, null, 5));
Assert.IsNotNull(u2);
Assert.AreEqual(3, u2.Count);
try
{
Job u = new Job();
u.Id = targetJob;
rep.DeleteJob(u, new Options(JobCmdFlags.Input));
}
catch (P4Exception e)
{
Assert.AreEqual(805372934, e.ErrorCode, "Usage: job -i [ -f ]\nUnexpected arguments.\n");
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void GetServerMetaDataTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
var serverRoot = Utilities.TestServerRoot(TestDir, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
#pragma warning disable 612
ServerMetaData s = rep.GetServerMetaData();
#pragma warning restore 612
Assert.IsNotNull(s);
if (unicode == true)
{
Assert.AreEqual(s.UnicodeEnabled, true);
}
Assert.AreEqual(s.Root, serverRoot);
Assert.AreEqual(s.CaseSensitive, false);
Assert.AreEqual(s.MoveEnabled, true);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void DeleteOtherUserWithoutFlagTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "alex_space";
string targetUser = "******";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 7, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
User u = new User();
u.Id = targetUser;
try
{
rep.DeleteUser(u, null);
}
catch (P4Exception e)
{
Assert.AreEqual(822483030, e.ErrorCode, "Not user '%targetUser'; use -f to force delete.\n");
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void CreateGroupWithOwnerFlagTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "Alice_space";
string targetGroup = "test";
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Group u = new Group();
u.Id = targetGroup;
u.OwnerNames = new List <string> {
"Alex"
};
try
{
Group u2 = rep.CreateGroup(u, new Options(GroupCmdFlags.OwnerAccess));
}
catch (P4Exception e)
{
Assert.AreEqual(838867416, e.ErrorCode, "Error in group specification.\nUser 'Alex' is not an owner of group '%targetGroup'.\n");
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void SubmitTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
Changelist change = new Changelist(5, true);
change.initialize(con);
SubmitResults sr = change.Submit(null);
Assert.IsNotNull(sr);
Assert.AreEqual(1, sr.Files.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void DeleteChangelistTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 7, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Changelist c = new Changelist();
c.Description = "New changelist for unit test";
Changelist newGuy = rep.CreateChangelist(c, null);
rep.DeleteChangelist(newGuy, null);
Changelist deadGuy = null;
try
{
deadGuy = rep.GetChangelist(newGuy.Id);
}
catch { }
Assert.IsNull(deadGuy);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for GetServerMetaDatajob076750
///</summary>
public void GetServerMetaDataTestjob076750(bool unicode)
{
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
var serverRoot = Utilities.TestServerRoot(TestDir, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
#pragma warning disable 612
ServerMetaData s = rep.GetServerMetaData();
#pragma warning restore 612
Assert.IsNotNull(s);
DateTime dt = new DateTime(1, 1, 1, 0, 0, 0); //(1 / 1 / 0001 12:00:00 AM)
Assert.AreNotEqual(s.Version.Date, dt);
if (unicode == true)
{
Assert.AreEqual(s.UnicodeEnabled, true);
}
Assert.AreEqual(s.Root, serverRoot);
Assert.AreEqual(s.CaseSensitive, false);
Assert.AreEqual(s.MoveEnabled, true);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
}
