public ISimpleApiClient Create(UriString repositoryUrl)
{
var hostAddress = HostAddress.Create(repositoryUrl);
return cache.GetOrAdd(repositoryUrl, new SimpleApiClient(hostAddress, repositoryUrl,
new GitHubClient(productHeader, new SimpleCredentialStore(hostAddress), hostAddress.ApiUri),
lazyEnterpriseProbe, lazyWikiProbe));
}
public async Task<List<VideoAppModels.VideoFeeds>> GetVideosByTitleSearch(string searchParameter)
{
UriString parameters = new UriString();
parameters.Add("searchParameter", searchParameter);
var obj = await base.GetAsync<List<VideoAppModels.VideoFeeds>>(parameters, "GetVideosByTitleSearch", "Video");
return obj;
}
internal SimpleApiClient(HostAddress hostAddress, UriString repoUrl, GitHubClient githubClient,
Lazy<IEnterpriseProbeTask> enterpriseProbe, Lazy<IWikiProbe> wikiProbe)
{
HostAddress = hostAddress;
OriginalUrl = repoUrl;
client = githubClient;
this.enterpriseProbe = enterpriseProbe;
this.wikiProbe = wikiProbe;
}
public void ParsesWellFormedUrlComponents(string url, string expectedHost, string owner, string repositoryName)
{
var cloneUrl = new UriString(url);
Assert.Equal(cloneUrl.Host, expectedHost);
Assert.Equal(cloneUrl.Owner, owner);
Assert.Equal(cloneUrl.RepositoryName, repositoryName);
Assert.False(cloneUrl.IsFileUri);
}
/// <summary>
/// Initializes a new instance of the <see cref="RepositoryModelBase"/> class.
/// </summary>
/// <param name="name">The repository name.</param>
/// <param name="cloneUrl">The repository's clone URL.</param>
protected RepositoryModelBase(
string name,
UriString cloneUrl)
{
Guard.ArgumentNotEmptyString(name, nameof(name));
Guard.ArgumentNotNull(cloneUrl, nameof(cloneUrl));
Name = name;
CloneUrl = cloneUrl;
}
public GitReferenceModel(string @ref, string label, string sha, UriString repositoryCloneUri)
{
Guard.ArgumentNotEmptyString(@ref, nameof(@ref));
Guard.ArgumentNotEmptyString(sha, nameof(sha));
Ref = @ref;
Label = label;
Sha = sha;
RepositoryCloneUrl = repositoryCloneUri;
}
public void ParsesLocalFileUris(string path)
{
var cloneUrl = new UriString(path);
Assert.Equal(cloneUrl.Host, "");
Assert.Equal(cloneUrl.Owner, "");
Assert.Equal(cloneUrl.RepositoryName, "foo");
Assert.Equal(cloneUrl.ToString(), path.Replace('\\', '/'));
Assert.True(cloneUrl.IsFileUri);
}
public SimpleApiClient(UriString repoUrl, IGitHubClient githubClient,
Lazy<IEnterpriseProbeTask> enterpriseProbe, Lazy<IWikiProbe> wikiProbe)
{
Guard.ArgumentNotNull(repoUrl, nameof(repoUrl));
Guard.ArgumentNotNull(githubClient, nameof(githubClient));
HostAddress = HostAddress.Create(repoUrl);
OriginalUrl = repoUrl;
client = githubClient;
this.enterpriseProbe = enterpriseProbe;
this.wikiProbe = wikiProbe;
}
public ISimpleApiClient Create(UriString repositoryUrl)
{
var contains = cache.ContainsKey(repositoryUrl);
if (contains)
return cache[repositoryUrl];
lock (cache)
{
if (!cache.ContainsKey(repositoryUrl))
{
var hostAddress = HostAddress.Create(repositoryUrl);
var apiBaseUri = hostAddress.ApiUri;
cache.Add(repositoryUrl, new SimpleApiClient(hostAddress, repositoryUrl, new GitHubClient(productHeader, new SimpleCredentialStore(hostAddress), apiBaseUri), lazyEnterpriseProbe, lazyWikiProbe));
}
return cache[repositoryUrl];
}
}
public void ConvertsBackToString()
{
var uri = new UriString("http://github.com/foo/bar/");
string cloneUri = uri;
Assert.Equal(cloneUri, "http://github.com/foo/bar/");
}
public void ConvertsNullToNull()
{
UriString cloneUri = (string)null;
Assert.That(cloneUri, Is.Null);
}
public async Task ResumingDownloadsWorks()
{
Stopwatch watch;
ILogging logger;
StartTest(out watch, out logger);
var fileSystem = NPath.FileSystem;
var gitLfs = new UriString($"http://localhost:{server.Port}/git-lfs.zip");
var gitLfsMd5 = new UriString($"http://localhost:{server.Port}/git-lfs.zip.md5");
var downloadTask = new DownloadTask(TaskManager.Token, fileSystem, gitLfsMd5, TestBasePath);
StartTrackTime(watch, logger, gitLfsMd5);
var task = await TaskEx.WhenAny(downloadTask.Start().Task, TaskEx.Delay(Timeout));
StopTrackTimeAndLog(watch, logger);
task.ShouldBeEquivalentTo(downloadTask.Task);
var downloadPath = await downloadTask.Task;
var md5 = downloadPath.ReadAllText();
Assert.NotNull(md5);
StartTrackTime(watch, logger, gitLfs);
downloadTask = new DownloadTask(TaskManager.Token, fileSystem, gitLfs, TestBasePath);
StartTrackTime(watch, logger, gitLfsMd5);
task = await TaskEx.WhenAny(downloadTask.Start().Task, TaskEx.Delay(Timeout));
StopTrackTimeAndLog(watch, logger);
task.ShouldBeEquivalentTo(downloadTask.Task);
downloadPath = await downloadTask.Task;
Assert.NotNull(downloadPath);
var md5Sum = downloadPath.CalculateMD5();
md5Sum.Should().BeEquivalentTo(md5);
var downloadPathBytes = downloadPath.ReadAllBytes();
Logger.Trace("File size {0} bytes", downloadPathBytes.Length);
var cutDownloadPathBytes = downloadPathBytes.Take(downloadPathBytes.Length - 1000).ToArray();
downloadPath.Delete();
new NPath(downloadPath + ".partial").WriteAllBytes(cutDownloadPathBytes);
downloadTask = new DownloadTask(TaskManager.Token, fileSystem, gitLfs, TestBasePath);
StartTrackTime(watch, logger, gitLfs);
task = await TaskEx.WhenAny(downloadTask.Start().Task, TaskEx.Delay(Timeout));
StopTrackTimeAndLog(watch, logger);
task.ShouldBeEquivalentTo(downloadTask.Task);
downloadPath = await downloadTask.Task;
md5Sum = downloadPath.CalculateMD5();
md5Sum.Should().BeEquivalentTo(md5);
}
public void ShouldDeleteFromCacheWhenLoadReturnsNullFromConnectionManagerDueToUserMismatch()
{
const string connectionsCachePath = @"c:\UserCachePath\";
const string connectionsCacheFile = @"c:\UserCachePath\connections.json";
const string cachedUsername = "******";
const string credentialedUsername = "******";
const string token = "SomeToken";
var hostUri = new UriString("https://github.com/");
var fileSystem = SubstituteFactory.CreateFileSystem(new CreateFileSystemOptions
{
FilesThatExist = new List <string> {
connectionsCacheFile
},
FileContents = new Dictionary <string, IList <string> > {
{ connectionsCacheFile, new List <string> {
$@"[{{""Host"":""https://github.com/"",""Username"":""{cachedUsername}""}}]"
} }
}
});
NPath.FileSystem = fileSystem;
var environment = SubstituteFactory.CreateEnvironment();
environment.UserCachePath.Returns(info => connectionsCachePath.ToNPath());
environment.FileSystem.Returns(fileSystem);
var credentialManager = Substitute.For <ICredentialManager>();
credentialManager.Load(hostUri).Returns(info =>
{
var credential = Substitute.For <ICredential>();
credential.Username.Returns(credentialedUsername);
credential.Token.Returns(token);
credential.Host.Returns(hostUri);
return(TaskEx.FromResult(credential));
});
var keychain = new Keychain(environment, credentialManager);
keychain.Initialize();
fileSystem.Received(1).FileExists(connectionsCacheFile);
fileSystem.DidNotReceive().FileDelete(Args.String);
fileSystem.Received(1).ReadAllText(connectionsCacheFile);
fileSystem.DidNotReceive().ReadAllLines(Args.String);
fileSystem.DidNotReceive().WriteAllText(Args.String, Args.String);
fileSystem.DidNotReceive().WriteAllLines(Args.String, Arg.Any <string[]>());
credentialManager.DidNotReceive().Load(Args.UriString);
credentialManager.DidNotReceive().HasCredentials();
credentialManager.DidNotReceive().Delete(Args.UriString);
credentialManager.DidNotReceive().Save(Arg.Any <ICredential>());
fileSystem.ClearReceivedCalls();
var uriString = keychain.Hosts.FirstOrDefault();
var keychainAdapter = keychain.Load(uriString).Result;
keychainAdapter.Credential.Should().BeNull();
keychainAdapter.OctokitCredentials.AuthenticationType.Should().Be(AuthenticationType.Anonymous);
keychainAdapter.OctokitCredentials.Login.Should().BeNull();
keychainAdapter.OctokitCredentials.Password.Should().BeNull();
fileSystem.DidNotReceive().FileExists(Args.String);
fileSystem.DidNotReceive().ReadAllText(Args.String);
fileSystem.DidNotReceive().FileDelete(Args.String);
fileSystem.Received(1).WriteAllText(connectionsCacheFile, "[]");
fileSystem.DidNotReceive().WriteAllLines(Args.String, Arg.Any <string[]>());
credentialManager.Received(1).Load(hostUri);
credentialManager.DidNotReceive().HasCredentials();
credentialManager.DidNotReceive().Delete(Args.UriString);
credentialManager.DidNotReceive().Save(Arg.Any <ICredential>());
}
internal ConnectionStringInfo([NotNull] UriString uri, [CanBeNull] string value)
: base(uri, ImmutableSession.Empty.Set(Use <IResourceNamespace> .Namespace, x => x.Format, MimeType.Text))
{
_value = value;
}
private void RenderForm(Caller caller, PaperContext context, Entity entity, object[] args, object graph = null)
{
var href = new UriString(context.Path.Substring(1)).Append($"-{caller.Method.Name}");
var action = new EntityAction();
action.Name = caller.Method.Name;
action.Title = caller.Method.Name.ChangeCase(TextCase.ProperCase);
action.Href = href;
action.Method = MethodNames.Post;
var parameters = caller.Method.GetParameters();
for (var i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
var parameterValue = caller.Args[i];
var name = Conventions.MakeName(parameter.Name);
var isValue = IsValue(parameter.ParameterType);
var isArray = !isValue && typeof(IEnumerable).IsAssignableFrom(parameter.ParameterType);
var isForm = !isValue && !isArray && typeof(IForm).IsAssignableFrom(parameter.ParameterType);
if (isValue)
{
action.AddField($"Form.{name}", opt =>
{
opt.SetDefaults(parameter);
opt.SetHidden(true);
if (parameterValue != null)
{
opt.SetValue(parameterValue);
}
});
}
else if (isForm)
{
var properties = parameter.ParameterType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (var property in properties)
{
var fieldName = Conventions.MakeName(property.Name);
var fieldValue = (parameterValue != null) ? property.GetValue(parameterValue) : null;
action.AddField($"Form.{name}.{fieldName}", opt =>
{
opt.SetDefaults(property);
if (fieldValue != null)
{
opt.SetValue(fieldValue);
}
});
}
}
else if (isArray)
{
var elementType = TypeOf.CollectionElement(parameter.ParameterType);
var properties = elementType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
var keys = (
from property in properties
select Conventions.MakeName(property.Name)
).ToArray();
action.AddField("Records", opt => opt
// XXX: FIXME: Esta propriedade agora deve pertencer a uma entidade.
//.SetTitle("Registros Afetados")
.SetPlaceholder("Selecione os registros afetados")
.SetType(FieldTypeNames.SelectRecord)
.SetDataType(DataTypeNames.Record)
.SetMultiline(true)
.SetProvider(provider => provider
.AddRel(RelNames.Self)
.SetKeys(keys)
)
.SetAllowMany()
.SetRequired()
);
}
else
{
foreach (var propertyName in parameterValue._GetPropertyNames())
{
var property = parameterValue._GetPropertyInfo(propertyName);
var fieldName = Conventions.MakeName(propertyName);
var fieldValue = parameterValue._Get(propertyName);
action.AddField($"Record.{fieldName}", opt =>
{
opt.SetDefaults(property);
opt.SetHidden(true);
if (fieldValue != null)
{
opt.SetValue(fieldValue);
}
});
}
}
}
entity.AddAction(action);
}
public void ShouldConnectSetCredentialsTokenAndSave()
{
const string connectionsCachePath = @"c:\UserCachePath\";
const string connectionsCacheFile = @"c:\UserCachePath\connections.json";
const string username = "******";
const string password = "******";
const string token = "SomeToken";
var hostUri = new UriString("https://github.com/");
var fileSystem = SubstituteFactory.CreateFileSystem();
NPath.FileSystem = fileSystem;
var environment = SubstituteFactory.CreateEnvironment();
environment.UserCachePath.Returns(info => connectionsCachePath.ToNPath());
environment.FileSystem.Returns(fileSystem);
var credentialManager = Substitute.For <ICredentialManager>();
var keychain = new Keychain(environment, credentialManager);
keychain.Initialize();
fileSystem.Received(1).FileExists(connectionsCacheFile);
fileSystem.DidNotReceive().ReadAllText(Args.String);
fileSystem.DidNotReceive().ReadAllLines(Args.String);
fileSystem.DidNotReceive().WriteAllText(Args.String, Args.String);
fileSystem.DidNotReceive().FileDelete(Args.String);
fileSystem.ClearReceivedCalls();
credentialManager.DidNotReceive().Load(Args.UriString);
credentialManager.DidNotReceive().HasCredentials();
credentialManager.DidNotReceive().Delete(Args.UriString);
credentialManager.DidNotReceive().Save(Arg.Any <ICredential>());
keychain.HasKeys.Should().BeFalse();
keychain.Hosts.Should().BeEmpty();
var keychainAdapter = keychain.Connect(hostUri);
keychainAdapter.Credential.Should().BeNull();
keychainAdapter.Set(new Credential(hostUri, username, password));
keychainAdapter.Credential.Should().NotBeNull();
keychainAdapter.Credential.Host.Should().Be(hostUri);
keychainAdapter.Credential.Username.Should().Be(username);
keychainAdapter.Credential.Token.Should().Be(password);
keychainAdapter.Update(token, username);
keychainAdapter.Credential.Should().NotBeNull();
keychainAdapter.Credential.Host.Should().Be(hostUri);
keychainAdapter.Credential.Username.Should().Be(username);
keychainAdapter.Credential.Token.Should().Be(token);
keychain.SaveToSystem(hostUri);
fileSystem.DidNotReceive().FileExists(Args.String);
fileSystem.DidNotReceive().FileDelete(Args.String);
fileSystem.DidNotReceive().ReadAllText(Args.String);
fileSystem.DidNotReceive().ReadAllLines(Args.String);
fileSystem.Received(1).WriteAllText(connectionsCacheFile, @"[{""Host"":""https://github.com"",""Username"":""SomeUser""}]");
credentialManager.DidNotReceive().Load(Args.UriString);
credentialManager.DidNotReceive().HasCredentials();
credentialManager.Received(1).Delete(hostUri);
credentialManager.Received(1).Save(Arg.Any <ICredential>());
}
public void RepositoryParsing(string url, string expectedRepository)
{
var uriString = new UriString(url);
Assert.AreEqual(expectedRepository, uriString.RepositoryName);
}
public void ProtocolParsing(string url, string expectedProtocol)
{
var uriString = new UriString(url);
Assert.AreEqual(expectedProtocol, uriString.Protocol);
}
public void OwnerParsing(string url, string expectedOwner)
{
var uriString = new UriString(url);
Assert.AreEqual(expectedOwner, uriString.Owner);
}
public void LengthParsing(string url, int expectedLength)
{
var uriString = new UriString(url);
Assert.AreEqual(uriString.Length, expectedLength);
}
public void HostParsing(string url, string expectedHost)
{
var uriString = new UriString(url);
Assert.AreEqual(expectedHost, uriString.Host);
}
public void FilenameParsing(string url, string expectedFilename)
{
var uriString = new UriString(url);
Assert.AreEqual(expectedFilename, uriString.Filename);
}
public void ConvertsToCloneUri()
{
UriString cloneUri = "http://github.com/foo/bar/";
Assert.That("github.com", Is.EqualTo(cloneUri.Host));
}
protected override Task <IResourceInfo> DeleteAsyncInternal(UriString uri, IImmutableSession metadata)
{
return(Task.FromResult(default(IResourceInfo)));
}
public async Task <Ret <Content> > RequestAsync(
string uri
, string method
, object upData
, string upType
, string upCharset
, string downType
, string downCharset
)
{
try
{
if (!uri.Contains("://"))
{
uri = new UriString(Endpoint).Combine(Prefix).Combine(uri);
}
var request = HttpWebRequest.CreateHttp(uri);
request.Method = method;
request.Accept = downType;
request.Headers[HeaderNames.AcceptCharset] = downCharset;
if (upData != null)
{
request.ContentType = $"{upType}; charset={upCharset}";
using (var stream = request.GetRequestStream())
{
await SerializeAsync(upData, upType, upCharset, stream);
}
}
HttpWebResponse response;
try
{
response = (HttpWebResponse)request.GetResponse();
}
catch (WebException ex)
{
response = ex.Response as HttpWebResponse;
if (response == null)
{
throw;
}
}
using (response)
{
var downData = new Content {
Href = uri
};
using (var stream = response.GetResponseStream())
{
downData.Data = await DeserializeAsync(stream, downType, downCharset);
}
var headers = new HashMap <string>(response.Headers.Count);
foreach (string key in response.Headers.Keys)
{
headers[key] = response.Headers[key];
}
return(new Ret <Content>
{
Status = new Ret.RetStatus
{
Code = response.StatusCode,
Headers = headers
},
Value = downData
});
}
}
catch (Exception ex)
{
ex.Trace();
return(ex);
}
}
public static UriString FixPort(this UriString url, int port)
{
var uri = url.ToUri();
return(UriString.TryParse(new UriBuilder(uri.Scheme, uri.Host, port, uri.PathAndQuery).Uri.ToString()));
}
public void DependsOnOwnerAndRepoNameNotBeingNull(string url, string expectedNameWithOwner)
{
var cloneUrl = new UriString(url);
Assert.Equal(cloneUrl.NameWithOwner, expectedNameWithOwner);
}
private static object Validate(object value, IEnumerable <ValidationAttribute> validations, UriString uri)
{
foreach (var validation in validations)
{
validation.Validate(value, uri);
}
return(value);
}
public void ConvertsToCloneUri()
{
UriString cloneUri = "http://github.com/foo/bar/";
Assert.Equal(cloneUri.Host, "github.com");
}
/// <summary>
/// Returns the URL of the remote for the specified <see cref="repository"/>. If the repository
/// is null or no remote named origin exists, this method returns null
/// </summary>
/// <param name="repository">The repository to look at for the remote.</param>
/// <param name="remote">The name of the remote to look for</param>
/// <returns>Returns a <see cref="UriString"/> representing the uri of the remote normalized to a GitHub repository url or null if none found.</returns>
public UriString GetUri(IRepository repository, string remote = "origin")
{
return(UriString.ToUriString(GetRemoteUri(repository, remote)?.ToRepositoryUrl()));
}
public void ConvertsNullToNull()
{
UriString cloneUri = (string)null;
Assert.Null(cloneUri);
}
public void ShouldConnectSetCredentialsAndClear()
{
const string connectionsCachePath = @"c:\UserCachePath\";
const string connectionsCacheFile = @"c:\UserCachePath\connections.json";
const string username = "******";
const string password = "******";
const string token = "SomeToken";
var hostUri = new UriString("https://github.com/");
var fileSystem = SubstituteFactory.CreateFileSystem();
NPath.FileSystem = fileSystem;
var environment = SubstituteFactory.CreateEnvironment();
environment.UserCachePath.Returns(info => connectionsCachePath.ToNPath());
environment.FileSystem.Returns(fileSystem);
var credentialManager = Substitute.For <ICredentialManager>();
credentialManager.Delete(Args.UriString).Returns(info => TaskEx.FromResult(0));
credentialManager.Save(Arg.Any <ICredential>()).Returns(info => TaskEx.FromResult(0));
var keychain = new Keychain(environment, credentialManager);
keychain.Initialize();
fileSystem.Received(1).FileExists(connectionsCacheFile);
fileSystem.DidNotReceive().ReadAllText(Args.String);
fileSystem.DidNotReceive().ReadAllLines(Args.String);
fileSystem.DidNotReceive().WriteAllText(Args.String, Args.String);
fileSystem.DidNotReceive().FileDelete(Args.String);
fileSystem.ClearReceivedCalls();
credentialManager.DidNotReceive().Load(Args.UriString);
credentialManager.DidNotReceive().HasCredentials();
credentialManager.DidNotReceive().Delete(Args.UriString);
credentialManager.DidNotReceive().Save(Arg.Any <ICredential>());
keychain.HasKeys.Should().BeFalse();
keychain.Hosts.Should().BeEmpty();
var keychainAdapter = keychain.Connect(hostUri);
keychainAdapter.Credential.Should().BeNull();
keychainAdapter.OctokitCredentials.Should().NotBeNull();
keychainAdapter.OctokitCredentials.AuthenticationType.Should().Be(AuthenticationType.Anonymous);
keychainAdapter.OctokitCredentials.Login.Should().BeNull();
keychainAdapter.OctokitCredentials.Password.Should().BeNull();
keychain.SetCredentials(new Credential(hostUri, username, password));
keychainAdapter.Credential.Should().NotBeNull();
keychainAdapter.Credential.Host.Should().Be(hostUri);
keychainAdapter.Credential.Username.Should().Be(username);
keychainAdapter.Credential.Token.Should().Be(password);
keychainAdapter.OctokitCredentials.AuthenticationType.Should().Be(AuthenticationType.Basic);
keychainAdapter.OctokitCredentials.Login.Should().Be(username);
keychainAdapter.OctokitCredentials.Password.Should().Be(password);
keychain.Clear(hostUri, false).Wait();
keychainAdapter.Credential.Should().BeNull();
keychainAdapter.OctokitCredentials.AuthenticationType.Should().Be(AuthenticationType.Anonymous);
keychainAdapter.OctokitCredentials.Login.Should().BeNull();
keychainAdapter.OctokitCredentials.Password.Should().BeNull();
fileSystem.DidNotReceive().FileExists(Args.String);
fileSystem.DidNotReceive().FileDelete(Args.String);
fileSystem.DidNotReceive().ReadAllText(Args.String);
fileSystem.DidNotReceive().ReadAllLines(Args.String);
fileSystem.Received(1).WriteAllText(connectionsCacheFile, "[]");
credentialManager.DidNotReceive().Load(Args.UriString);
credentialManager.DidNotReceive().HasCredentials();
credentialManager.DidNotReceive().Delete(Args.UriString);
credentialManager.DidNotReceive().Save(Arg.Any <ICredential>());
}
public void ParsesWeirdUrlsAsWellAsPossible(string url, string expectedHost, string owner, string repositoryName)
{
var cloneUrl = new UriString(url);
Assert.Equal(cloneUrl.Host, expectedHost);
Assert.Equal(cloneUrl.Owner, owner);
Assert.Equal(cloneUrl.RepositoryName, repositoryName);
}
public void ResumingDownloadsWorks()
{
Stopwatch watch;
ILogging logger;
StartTest(out watch, out logger);
var fileSystem = Environment.FileSystem;
var gitLfs = new UriString($"http://localhost:{server.Port}/git-lfs.zip");
var gitLfsMd5 = new UriString($"http://localhost:{server.Port}/git-lfs.zip.MD5.txt");
var evtDone = new ManualResetEventSlim(false);
string md5 = null;
StartTrackTime(watch, logger, gitLfsMd5);
new DownloadTextTask(TaskManager.Token, fileSystem, gitLfsMd5, TestBasePath)
.Finally(r => {
md5 = r;
evtDone.Set();
})
.Start();
evtDone.Wait(Timeout).Should().BeTrue("Finally raised the signal");
StopTrackTimeAndLog(watch, logger);
evtDone.Reset();
Assert.NotNull(md5);
string downloadPath = null;
StartTrackTime(watch, logger, gitLfs);
new DownloadTask(TaskManager.Token, fileSystem, gitLfs, TestBasePath)
.Finally(r => {
downloadPath = r;
evtDone.Set();
})
.Start();
evtDone.Wait(Timeout).Should().BeTrue("Finally raised the signal");;
StopTrackTimeAndLog(watch, logger);
evtDone.Reset();
Assert.NotNull(downloadPath);
var md5Sum = fileSystem.CalculateFileMD5(downloadPath);
md5Sum.Should().BeEquivalentTo(md5);
var downloadPathBytes = fileSystem.ReadAllBytes(downloadPath);
Logger.Trace("File size {0} bytes", downloadPathBytes.Length);
var cutDownloadPathBytes = downloadPathBytes.Take(downloadPathBytes.Length - 1000).ToArray();
fileSystem.FileDelete(downloadPath);
fileSystem.WriteAllBytes(downloadPath, cutDownloadPathBytes);
StartTrackTime(watch, logger, "resuming download");
new DownloadTask(TaskManager.Token, fileSystem, gitLfs, TestBasePath)
.Finally(r => {
downloadPath = r;
evtDone.Set();
})
.Start();
evtDone.Wait(Timeout).Should().BeTrue("Finally raised the signal");;
StopTrackTimeAndLog(watch, logger);
evtDone.Reset();
var downloadHalfPathBytes = fileSystem.ReadAllBytes(downloadPath);
Logger.Trace("File size {0} Bytes", downloadHalfPathBytes.Length);
md5Sum = fileSystem.CalculateFileMD5(downloadPath);
md5Sum.Should().BeEquivalentTo(md5);
}
async Task<string> CreateRemote(IRepository repo, UriString cloneUri)
{
foreach (var remote in repo.Network.Remotes)
{
if (remote.Url == cloneUri)
{
return remote.Name;
}
}
var remoteName = CreateUniqueRemoteName(repo, cloneUri.Owner);
await gitClient.SetRemote(repo, remoteName, new Uri(cloneUri));
await gitClient.SetConfig(repo, $"remote.{remoteName}.{SettingCreatedByGHfVS}", "true");
return remoteName;
}
public void DependsOnOwnerAndRepoNameNotBeingNull(string url, string expectedNameWithOwner)
{
var cloneUrl = new UriString(url);
Assert.Equal(cloneUrl.NameWithOwner, expectedNameWithOwner);
}
public static bool IsIOnymous(this UriString uri) => SoftString.Comparer.Equals(uri.Scheme, ResourceProvider.DefaultScheme);
public void IsTrueOnlyForHttpAndHttps(string url, bool expected)
{
var uri = new UriString(url);
Assert.Equal(uri.IsHypertextTransferProtocol, expected);
}
public void CopyFrom(UriString uri)
{
CopyFromArgValue(uri.GetArg("sort"));
}
public void IsTrueOnlyForHttpAndHttps(string url, bool expected)
{
var uri = new UriString(url);
Assert.Equal(uri.IsHypertextTransferProtocol, expected);
}
public void ShouldLoadFromConnectionManager()
{
const string connectionsCachePath = @"c:\UserCachePath\";
const string connectionsCacheFile = @"c:\UserCachePath\connections.json";
var hostUri = new UriString("https://github.com/");
var fileSystem = SubstituteFactory.CreateFileSystem(new CreateFileSystemOptions {
FilesThatExist = new List <string> {
connectionsCacheFile
},
FileContents = new Dictionary <string, IList <string> > {
{ connectionsCacheFile, new List <string> {
@"[{""Host"":""https://github.com/"",""Username"":""SomeUser""}]"
} }
}
});
NPath.FileSystem = fileSystem;
var environment = SubstituteFactory.CreateEnvironment();
environment.UserCachePath.Returns(info => connectionsCachePath.ToNPath());
environment.FileSystem.Returns(fileSystem);
const string username = "******";
const string token = "SomeToken";
var credentialManager = Substitute.For <ICredentialManager>();
credentialManager.Load(hostUri).Returns(info =>
{
var credential = Substitute.For <ICredential>();
credential.Username.Returns(username);
credential.Token.Returns(token);
credential.Host.Returns(hostUri);
return(credential);
});
var keychain = new Keychain(environment, credentialManager);
keychain.Initialize();
fileSystem.Received(1).FileExists(connectionsCacheFile);
fileSystem.DidNotReceive().FileDelete(Args.String);
fileSystem.Received(1).ReadAllText(connectionsCacheFile);
fileSystem.DidNotReceive().ReadAllLines(Args.String);
fileSystem.DidNotReceive().WriteAllText(Args.String, Args.String);
fileSystem.DidNotReceive().WriteAllLines(Args.String, Arg.Any <string[]>());
var uriString = keychain.Hosts.FirstOrDefault();
var keychainAdapter = keychain.LoadFromSystem(uriString);
keychainAdapter.Credential.Username.Should().Be(username);
keychainAdapter.Credential.Token.Should().Be(token);
keychainAdapter.Credential.Host.Should().Be(hostUri);
credentialManager.Received(1).Load(hostUri);
credentialManager.DidNotReceive().HasCredentials();
credentialManager.DidNotReceive().Delete(Args.UriString);
credentialManager.DidNotReceive().Save(Arg.Any <ICredential>());
}
public void NormalizesSeparator(string uriString)
{
var path = new UriString(uriString);
new UriString("http://example.com/bar/baz").Equals(path);
}
public void NormalizesSeparator(string uriString)
{
var path = new UriString(uriString);
new UriString("http://example.com/bar/baz").Equals(path);
}
public async Task <CodeContainer> AcquireCodeContainerAsync(RemoteCodeContainer onlineCodeContainer, IProgress <ServiceProgressData> downloadProgress, CancellationToken cancellationToken)
{
var repository = new RepositoryModel(onlineCodeContainer.Name, UriString.ToUriString(onlineCodeContainer.DisplayUrl));
return(await RunAcquisition(downloadProgress, cancellationToken, repository));
}
public static string GetDraftKey(
UriString cloneUri,
string branchName)
{
return(Invariant($"pr|{cloneUri}|{branchName}"));
}
