public void Execute_ReturnsVersionString() { var command = new VersionCommand(); var result = command.Execute(new VersionArgs()); StringAssert.Contains("grep", result); }
static void Main(string[] args) { if (args.Length == 0) { PrintUsageHeader(); PrintUsage(); Environment.Exit(-1); } ICommand command = null; switch (args[0]) { case StartElectronCommand.COMMAND_NAME: command = new StartElectronCommand(args.Skip(1).ToArray()); break; case BuildCommand.COMMAND_NAME: command = new BuildCommand(args.Skip(1).ToArray()); break; case InitCommand.COMMAND_NAME: command = new InitCommand(args.Skip(1).ToArray()); break; case VersionCommand.COMMAND_NAME: command = new VersionCommand(args.Skip(1).ToArray()); break; case "--help": case "--h": case "help": PrintUsageHeader(); if (args.Length > 1) { PrintUsage(args[1]); } else { PrintUsage(); } break; default: Console.Error.WriteLine($"Unknown command {args[0]}"); PrintUsage(); Environment.Exit(-1); break; } if (command != null) { var success = command.ExecuteAsync().Result; if (!success) { Environment.Exit(-1); } } }
public void RefreshActiveSerialNexstarDevices() { _logger.LogInformation("Clearing old devices."); ActiveNexStarDevicePortNames.Clear(); _logger.LogInformation("Starting probe for NexStar devices."); string[] portNames = SerialPort.GetPortNames(); foreach (string portName in portNames) { SerialPortController testController = new SerialPortController(portName); VersionCommand versionCommandCommand = new VersionCommand(); try { testController.RunCommand(versionCommandCommand); if (versionCommandCommand.RawResultBytes != null) { ActiveNexStarDevicePortNames.Add(portName); _logger.LogInformation($"NexStar device found on port '{portName}'."); } } catch (TimeoutException) { _logger.LogInformation($"Probe timeout for port '{portName}'."); //ignore timeouts here, we are expecting some devices to not respond. } finally { testController.CloseSerialConnection(); } } _logger.LogInformation($"Probe finished found {ActiveNexStarDevicePortNames.Count} devices."); }
public void Run() { while (true) { string input = Console.ReadLine(); ICommand Command; switch (input.ToUpper()) { case "CLEAR": Command = new ClearCommand(); Command.Execute(); break; case "VERSION": Command = new VersionCommand(); Command.Execute(); break; default: Command = new NullCommand(); Command.Execute(); break; } } }
public static string Parse(List <string> args) { try { string result; var command = args.First(); if (command == Statics.Commands.Help) { var helpCommand = new HelpCommand(); var numberOfArgs = helpCommand.GetNumberOfArgs(); if (numberOfArgs == args.Count - 1) { result = helpCommand.Execute(new List <string>()); } else { throw new Exception("Command not recognized. Please use 'WixXmlGenerator -help' to see command the usages."); } } else if (command == Statics.Commands.Version) { var versionCommand = new VersionCommand(); var numberOfArgs = versionCommand.GetNumberOfArgs(); if (numberOfArgs == args.Count - 1) { result = versionCommand.Execute(new List <string>()); } else { throw new Exception("Command not recognized. Please use 'WixXmlGenerator -help' to see command the usages."); } } else if (command == Statics.Commands.Generate) { var generateCommand = new GenerateCommand(); var numberOfArgs = generateCommand.GetNumberOfArgs(); if (numberOfArgs == args.Count - 1) { result = generateCommand.Execute(args); } else { throw new Exception("Command not recognized. Please use 'WixXmlGenerator -help' to see command the usages."); } } else { throw new Exception("Command not recognized. Please use 'WixXmlGenerator -help' to see command the usages."); } return(result); } catch (Exception e) { throw e; } }
public void Setup() { _mockLog = new MockLog1(); _mockMigrationDir = new Mock <IMigrationDirectory>(); _versionCommand = new VersionCommand(_mockMigrationDir.Object); _versionCommand.Log = _mockLog; CreateDatabase(); }
public void VersionIsSet() { var version = VersionCommand.GetVersion(); Assert.False(string.IsNullOrEmpty(version)); Assert.NotEqual("1.0.0", version); Assert.NotEqual("0.0.0", version); }
private void OnCasparCgConnectionStatusChanged(object sender, ConnectionEventArgs e) { RaisePropertyChanged(nameof(IsConnected)); ConnectCommand?.RaiseCanExecuteChanged(); DisconnectCommand?.RaiseCanExecuteChanged(); PlayCommand?.RaiseCanExecuteChanged(); VersionCommand?.RaiseCanExecuteChanged(); }
public void ProcessRawResponseAsync_Invalid_Raw_Data_Should_Throw_exception(string rawData) { VersionCommand versionCommand = new VersionCommand(); byte[] rawBytes = rawData == null ? null : Encoding.UTF8.GetBytes(rawData); Assert.Throws <ClamAvException>(() => versionCommand.ProcessRawResponse(rawBytes)); }
public void Cannot_pass_arguments_to_version() { var stream = new MemoryStream(); var cmd = new VersionCommand(); cmd.SetContext(stream); cmd.Init("a"); Assert.AreEqual("CLIENT_ERROR Version accepts no paramters\r\n", ReadAll(stream)); }
public void Calling_init_with_no_params_succeed() { var stream = new MemoryStream(); var cmd = new VersionCommand(); cmd.SetContext(stream); Assert.IsTrue(cmd.Init()); }
public void SetUp() { originalOutput = Console.Out; output = new StringWriter(); Console.SetOut(output); commandOutputProvider = new CommandOutputProvider("Octo", "1.0.0", logger); versionCommand = new VersionCommand(commandOutputProvider); logger = new LoggerConfiguration().WriteTo.TextWriter(output).CreateLogger(); }
private void CreateVersionCommand(string arguments) { if (!string.IsNullOrEmpty(arguments)) { CreateInvalidCommand(); return; } _command = new VersionCommand(); this.State = ParserState.ReadyToDispatch; }
public static byte[] BuildVersionResponse(VersionCommand command) { byte[] value = null; if (command.OperationResult.ReturnResult == Result.SUCCESS) { string version = command.OperationResult.Value as string; value = MemcachedEncoding.BinaryConverter.GetBytes(version); } return(BuildResposne(command.Opcode, BinaryResponseStatus.no_error, command.Opaque, 0, null, value, null)); }
public void Will_return_assembly_version_as_memcached_version() { var stream = new MemoryStream(); var cmd = new VersionCommand(); cmd.SetContext(stream); cmd.Execute(); Assert.AreEqual("VERSION " + typeof(VersionCommand).Assembly.GetName().Version + "\r\n", ReadAll(stream)); }
public async Task ShouldStartWithProperArguments() { var starterMock = new Mock <IProcessStarter>(); starterMock.Setup(starter => starter.Start("--version", It.IsAny <TimeSpan>())) .Returns(Task.FromResult(0)); var command = new VersionCommand(starterMock.Object); await command.Execute(); starterMock.Verify(starter => starter.Start("--version", It.IsAny <TimeSpan>()), Times.Once()); }
public async Task ShouldStartWithProperTimeout() { var starterMock = new Mock <IProcessStarter>(); starterMock.Setup(starter => starter.Start(It.IsAny <string>(), TimeSpan.FromHours(1))) .Returns(Task.FromResult(0)); var command = new VersionCommand(starterMock.Object, string.Empty); await command.Execute(TimeSpan.FromHours(1)); starterMock.Verify(starter => starter.Start(It.IsAny <string>(), TimeSpan.FromHours(1)), Times.Once()); }
public void Version_Execute_ReturnString() { var command = new VersionCommand(_console, LoggerMock.GetLogger <VersionCommand>().Object, _versionService.Object); var resultMessage = command.Execute(); Assert.Contains("API Version: 1.0", resultMessage); Assert.Contains("CLI Version:", resultMessage); Assert.Contains("- Engine01: 1.0", resultMessage); Assert.Contains("- AspNetMvc: 1.0", resultMessage); }
public void ShouldExecuteDockerComposeWithNoArgumentsWithoutExceptions() { var starterMock = new Mock <IProcessStarter>(); starterMock.Setup(starter => starter.Start(It.IsAny <string>(), It.IsAny <TimeSpan>())) .Returns(Task.FromResult(0)); var command = new VersionCommand(starterMock.Object, string.Empty); Func <Task> execute = async() => await command.Execute(); execute.Should().NotThrow( "При условии установленного Docker Compose получение его версии всегда допустим."); }
public void Execute_WhenCalled_ReturnsViewWithVersionAsModel() { var command = new VersionCommand(); var versionArgs = new VersionArgs { Version = true }; var result = (CommandResult)command.Execute(versionArgs); var model = (VersionViewModel)result.Model; result.ViewName.ShouldEqual("Version"); model.Version.ShouldEqual("2.4.2"); }
public void ProcessRawResponseAsync_Valid_Raw_Data_Should_Return_PONG() { VersionCommand versionCommand = new VersionCommand(); const string expectedProgramVersion = "ClamAv 1.17.219"; string expectedVirusDbVersion = (DateTime.Now.Ticks % 11177).ToString(); byte[] rawBytes = Encoding.UTF8.GetBytes($"{expectedProgramVersion}/{expectedVirusDbVersion}/{DateTime.Now}"); VersionResult actual = versionCommand.ProcessRawResponse(rawBytes); actual.ProgramVersion.Should().Be(expectedProgramVersion); actual.VirusDbVersion.Should().Be(expectedVirusDbVersion); }
public override async void OnRun() { try { var releases = await Program.Instance.ghClient.Repository.Release.GetAll(Program.config.GitHubUpdateUsername, Program.config.GitHubUpdateRepository); var latest = VersionCommand.GetLatestVersion(releases); if (!Program.VERSION.Equals(latest)) { UpdateCommand.Update(); } } catch { } // quietly fail }
public async Task WriteCommandAsync_Should_Write_CommandName() { VersionCommand versionCommand = new VersionCommand(); await using MemoryStream memoryStream = new MemoryStream(); await versionCommand.WriteCommandAsync(memoryStream).ConfigureAwait(false); byte[] commandData = memoryStream.ToArray(); string actual = Encoding.UTF8.GetString(commandData); actual.Should() .Be($"{Consts.COMMAND_PREFIX_CHARACTER}{versionCommand.Name}{(char)Consts.TERMINATION_BYTE}"); }
public void ShouldCopyStandardOutputAndStandardErrorFromProcessStarterOnSuccessfulExecution() { var starterMock = new Mock <IProcessStarter>(); starterMock.Setup(starter => starter.Start(It.IsAny <string>(), It.IsAny <TimeSpan>())) .Returns(Task.FromResult(0)); starterMock.Setup(starter => starter.StandardOutput).Returns(() => new StringBuilder("stdout")); starterMock.Setup(starter => starter.StandardError).Returns(() => new StringBuilder("stderr")); var command = new VersionCommand(starterMock.Object, string.Empty); Func <Task> execute = async() => await command.Execute(); execute.Should().NotThrow(); command.StandardOutput.ToString().Should().Be("stdout"); command.StandardError.ToString().Should().Be("stderr"); }
public ICommand Build(string command) { string[] commandSplit = command?.Split(' '); ICommand createdCommand; switch (commandSplit[0]) { case "/help": case "/h": createdCommand = new HelpCommand(); break; case "/version": case "/v": createdCommand = new VersionCommand(); break; case "/clear": createdCommand = new ClearCommand(); break; case "/quit": case "/q": createdCommand = new QuitCommand(); break; case "/post": case "/p": createdCommand = new PostCommand(commandSplit); break; case "/retrieve": case "/r": createdCommand = new RetrieveCommand(commandSplit); break; case "/settings": createdCommand = new SettingsCommand(commandSplit); break; default: createdCommand = new DefaultCommand(); break; } return(createdCommand); }
public void ShouldThrowIfCommandExecutionExceededTimeout() { var starterMock = new Mock <IProcessStarter>(); starterMock.Setup(starter => starter.Start(It.IsAny <string>(), It.IsAny <TimeSpan>())) .Throws <TimeoutException>(); starterMock.Setup(starter => starter.StandardOutput).Returns(() => new StringBuilder()); starterMock.Setup(starter => starter.StandardError).Returns(() => new StringBuilder()); var command = new VersionCommand(starterMock.Object, string.Empty); Func <Task> execute = async() => await command.Execute(); execute.Should() .ThrowExactly <CommandExecutionException>() .WithMessage("*timeout*") .WithInnerExceptionExactly <TimeoutException>(); }
public ICommand Build(string command) { string[] commandSplit = command?.Split(' '); ICommand createdCommand; switch (commandSplit[0]) { case "/help": case "/h": createdCommand = new HelpCommand(); break; case "/version": case "/v": createdCommand = new VersionCommand(); break; case "/clear": case "/c": createdCommand = new ClearCommand(); break; case "/quit": case "/q": createdCommand = new QuitCommand(); break; case "/list": case "/l": createdCommand = new ListCommand(); break; case "/run": case "/r": createdCommand = new RunCommand(commandSplit); break; default: createdCommand = new DefaultCommand(); break; } return(createdCommand); }
public void VersionPacketTest() { var versionCommand = new VersionCommand(); byte[] packetBytes = versionCommand.GetPacketBytes(); Assert.Equal(0x00, packetBytes[0]); Assert.Equal(0x00, packetBytes[1]); Assert.Equal(0x00, packetBytes[2]); Assert.Equal(0x0b, packetBytes[3]); Assert.Equal(0x00, packetBytes[4]); Assert.Equal(0x00, packetBytes[5]); Assert.Equal(0x00, packetBytes[6]); Assert.Equal(0x01, packetBytes[7]); Assert.Equal(0x00, packetBytes[8]); Assert.Equal(0x01, packetBytes[9]); Assert.Equal(0x01, packetBytes[10]); }
protected override void Initialize() { GlobalContext.Properties["package"] = this; CheckCommandLine(); Logger.Initialise(IsCommandLine); SettingsCommand.Initialize(this); VersionCommand.Initialize(this); _buildVersionIncrementor = new BuildVersionIncrementor(this); _buildEvents = DTE.Events.BuildEvents; _buildVersionIncrementor.InitializeIncrementors(); _buildEvents.OnBuildBegin += _buildVersionIncrementor.OnBuildBegin; _buildEvents.OnBuildDone += _buildVersionIncrementor.OnBuildDone; base.Initialize(); }
protected override async System.Threading.Tasks.Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { await base.InitializeAsync(cancellationToken, progress); await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); GlobalContext.Properties["package"] = this; CheckCommandLine(); Logger.Initialise(IsCommandLine); SettingsCommand.Initialize(this); VersionCommand.Initialize(this); _buildVersionIncrementor = new BuildVersionIncrementor(this); _buildEvents = DTE.Events.BuildEvents; _buildVersionIncrementor.InitializeIncrementors(); #pragma warning disable VSTHRD101 // Avoid unsupported async delegates _buildEvents.OnBuildBegin += async(s, e) => await _buildVersionIncrementor.OnBuildBeginAsync(s, e); _buildEvents.OnBuildDone += async(s, e) => await _buildVersionIncrementor.OnBuildDoneAsync(s, e); #pragma warning restore VSTHRD101 // Avoid unsupported async delegates }
/// <summary> /// Get the version string of the VM /// </summary> /// <returns></returns> private async Task<VersionCommand.Reply> Version() { VersionCommand command = new VersionCommand(); await _jdwp.SendCommandAsync(command); var reply = command.GetReply(); return reply; }
public async Task LoginAsync(UserStatus initialStatus = UserStatus.Online) { await @lock.WriterLockAsync(); try { if (IsLoggedIn) return; IConnection connection = null; ConnectionStream stream = null; CommandReader reader = null; CommandWriter writer = null; ResponseTracker responseTracker = null; IConnectableObservable<Command> commands = null; IDisposable commandsDisposable = null; int transferCount = 0; SocketEndPoint endPoint = SocketEndPoint.Parse("messenger.hotmail.com:1863"); string authTicket = null; while (authTicket == null) { connection = new SocketConnection(); await connection.ConnectAsync(endPoint); stream = new ConnectionStream(connection); writer = new CommandWriter(stream); reader = new CommandReader(stream, new Dictionary<string, Type> { { "VER", typeof(VersionCommand) }, { "CVR", typeof(ClientVersionCommand) }, { "USR", typeof(AuthenticateCommand) }, { "XFR", typeof(TransferCommand) }, { "SYN", typeof(SynchronizeCommand) }, { "SBS", typeof(SbsCommand) }, { "MSG", typeof(MessageCommand) }, { "LST", typeof(UserCommand) }, { "LSG", typeof(GroupCommand) }, { "BPR", typeof(UserPropertyCommand) }, { "BLP", typeof(PrivacySettingCommand) }, { "GTC", typeof(PrivacySettingCommand) }, { "CHG", typeof(ChangeStatusCommand) }, { "UBX", typeof(BroadcastCommand) }, { "PRP", typeof(LocalPropertyCommand) }, { "NLN", typeof(UserOnlineCommand) }, { "ILN", typeof(InitialUserOnlineCommand) }, { "FLN", typeof(UserOfflineCommand) }, { "UUX", typeof(SendBroadcastCommand) }, { "NOT", typeof(NotificationCommand) }, { "QNG", typeof(PingCommand) }, { "CHL", typeof(ChallengeCommand) }, { "ADC", typeof(AddContactCommand) }, { "REM", typeof(RemoveContactCommand) }, { "ADG", typeof(AddGroupCommand) }, { "RMG", typeof(RemoveGroupCommand) }, { "REG", typeof(RenameGroupCommand) }, { "QRY", typeof(AcceptChallengeCommand) }, { "RNG", typeof(RingCommand) }, { "SBP", typeof(ChangeUserPropertyCommand) }, { "IMS", typeof(EnableIMCommand) }, }); commands = reader.GetReadObservable().Publish(); responseTracker = new ResponseTracker(writer, commands); commandsDisposable = commands.Connect(); var versionCommand = new VersionCommand("MSNP12"); var versionResponse = await responseTracker.GetResponseAsync<VersionCommand>(versionCommand, defaultTimeout); if (versionResponse.Versions.Length == 0) throw new ProtocolNotAcceptedException(); var clientVersionCommand = new ClientVersionCommand { LocaleId = "0x0409", OsType = "winnt", OsVersion = "5.0", Architecture = "1386", LibraryName = "MSMSGS", ClientVersion = "5.0.0482", ClientName = "WindowsMessenger", LoginName = credentials.LoginName, }; await responseTracker.GetResponseAsync<ClientVersionCommand>(clientVersionCommand, defaultTimeout); var userCommand = new AuthenticateCommand("TWN", "I", credentials.LoginName); var userResponse = await responseTracker.GetResponseAsync(userCommand, new Type[] { typeof(AuthenticateCommand), typeof(TransferCommand) }, defaultTimeout); if (userResponse is AuthenticateCommand) { authTicket = (userResponse as AuthenticateCommand).Argument; } else if (userResponse is TransferCommand) { TransferCommand transferResponse = userResponse as TransferCommand; if (transferCount > 3) throw new InvalidOperationException("The maximum number of redirects has been reached."); transferCount++; endPoint = SocketEndPoint.Parse(transferResponse.Host); commandsDisposable.Dispose(); reader.Close(); writer.Close(); connection.Dispose(); } } PassportAuthentication auth = new PassportAuthentication(); string authToken = await auth.GetToken(credentials.LoginName, credentials.Password, authTicket); var authCommand = new AuthenticateCommand("TWN", "S", authToken); var authResponse = await responseTracker.GetResponseAsync<AuthenticateCommand>(authCommand, defaultTimeout); var synCommand = new SynchronizeCommand(syncTimeStamp1 ?? "0", syncTimeStamp2 ?? "0"); var synResponse = await responseTracker.GetResponseAsync<SynchronizeCommand>(synCommand, defaultTimeout); IDisposable syncCommandsSubscription = null; List<Command> syncCommands = null; if (synResponse.TimeStamp1 != syncTimeStamp1 || synResponse.TimeStamp2 != syncTimeStamp2) { syncCommands = new List<Command>(); Type[] syncTypes = new Type[] { typeof(MessageCommand), typeof(UserCommand), typeof(GroupCommand), typeof(LocalPropertyCommand), typeof(PrivacySettingCommand), }; syncCommandsSubscription = commands .Where(c => syncTypes.Contains(c.GetType())) .Catch(Observable.Empty<Command>()) .Subscribe(c => syncCommands.Add(c)); //if we're expecting users/groups, wait for them before we proceed if (synResponse.UserCount + synResponse.GroupCount > 0) { await commands .Where(c => c is UserCommand || c is GroupCommand) .Take(synResponse.UserCount + synResponse.GroupCount) .Timeout(defaultTimeout); } } UserCapabilities capabilities = 0; MSNObject displayPicture = MSNObject.Empty; if (LocalUser != null) { capabilities = LocalUser.Capabilities; displayPicture = LocalUser.DisplayPicture; } Command changeStatusCommand = new ChangeStatusCommand(User.StatusToString(UserStatus.Online), (uint)capabilities, displayPicture != MSNObject.Empty ? displayPicture.ToString() : "0"); await responseTracker.GetResponseAsync(changeStatusCommand, defaultTimeout); if (syncCommandsSubscription != null) syncCommandsSubscription.Dispose(); this.writer = writer; this.reader = reader; this.stream = stream; this.connection = connection; this.responseTracker = responseTracker; this.commands = commands; this.commandsDisposable = commandsDisposable; if (LocalUser == null) { LocalUser = new LocalUser(this, credentials.LoginName); userCache.Add(credentials.LoginName, new WeakReference(LocalUser)); } LocalUser.Status = initialStatus; SyncEvents syncEvents = null; if (syncCommands != null) { syncTimeStamp1 = synResponse.TimeStamp1; syncTimeStamp2 = synResponse.TimeStamp2; syncEvents = ProcessSyncCommands(syncCommands); } var commandsSafe = commands .Catch<Command, ConnectionErrorException>(tx => Observable.Empty<Command>()); commandsSafe.OfType<MessageCommand>().Subscribe(cmd => HandleMessages(cmd, connection)); commandsSafe.OfType<RingCommand>().Subscribe(cmd => HandleRings(cmd, connection)); commandsSafe.OfType<BroadcastCommand>().Subscribe(cmd => HandleBroadcasts(cmd, connection)); commandsSafe.OfType<NotificationCommand>().Subscribe(cmd => HandleNotifications(cmd, connection)); commandsSafe.OfType<AddContactCommand>().Subscribe(cmd => HandleNewUsers(cmd, connection)); commandsSafe.OfType<OutCommand>().Subscribe(cmd => HandleOut(cmd, connection)); commandsSafe.OfType<ChallengeCommand>().Subscribe(cmd => HandleChallenges(cmd, connection)); commandsSafe.OfType<UserOnlineCommand>().Subscribe(cmd => HandleOnlineUsers(cmd, connection)); commandsSafe.OfType<InitialUserOnlineCommand>().Subscribe(cmd => HandleOnlineUsers(cmd, connection)); commandsSafe.OfType<UserOfflineCommand>().Subscribe(cmd => HandleOfflineUsers(cmd, connection)); connection.Error += connection_Error; IsLoggedIn = true; OnLoggedIn(); OnUserStatusChanged(new UserStatusEventArgs(LocalUser, initialStatus, UserStatus.Offline, true)); if (syncEvents != null) RaiseSyncEvents(syncEvents); } finally { @lock.WriterRelease(); } }
public static Version GetVersion() { LazyInitialize(); var command = new VersionCommand(); NonPersistentClient.Execute(command); string firstLine = command.Result.Split( new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries).First(); var re = new Regex(@"\(version\s+(?<version>[0-9.]+)(-rc)?(\+\d+-[a-f0-9]+)?\)", RegexOptions.IgnoreCase); Match ma = re.Match(firstLine); if (!ma.Success) throw new InvalidOperationException( string.Format(CultureInfo.InvariantCulture, "Unable to locate Mercurial version number in '{0}'", firstLine)); string versionString = ma.Groups["version"].Value; switch (versionString.Split('.').Length) { case 1: return new Version(string.Format(CultureInfo.InvariantCulture, "{0}.0.0.0", versionString)); case 2: return new Version(string.Format(CultureInfo.InvariantCulture, "{0}.0.0", versionString)); case 3: return new Version(string.Format(CultureInfo.InvariantCulture, "{0}.0", versionString)); case 4: return new Version(versionString); default: throw new InvalidOperationException( string.Format(CultureInfo.InvariantCulture, "Incorrect version number length, too many or too few parts: {0}", versionString)); } }