shelly 0.0.10 → 0.0.11

data/lib/shelly/cli/account.rb

@@ -1,61 +0,0 @@
-require "shelly/user"
-
-module Shelly
-  module CLI
-    class Account < Thor
-      namespace :account
-      include Helpers
-
-      desc "register [EMAIL]", "Registers new user account on Shelly Cloud"
-      def register(email = nil)
-        say "Registering with email: #{email}" if email
-        user = User.new(email || ask_for_email, ask_for_password)
-        user.register
-        if user.ssh_key_exists?
-          say "Uploading your public SSH key from #{user.ssh_key_path}"
-        end
-        say "Successfully registered!"
-        say "Check you mailbox for email address confirmation"
-      rescue Client::APIError => e
-        if e.message == "Validation Failed"
-          e.errors.each { |error| say "#{error.first} #{error.last}" }
-          exit 1
-        end
-      end
-
-      # Fix for bug with displaying help for subcommands
-      # http://stackoverflow.com/questions/5663519/namespacing-thor-commands-in-a-standalone-ruby-executable
-      def self.banner(task, namespace = true, subcommand = false)
-        "#{basename} #{task.formatted_usage(self, true, subcommand)}"
-      end
-
-      # FIXME: move to helpers
-      no_tasks do
-        def ask_for_email
-          email_question = User.guess_email.blank? ? "Email:" : "Email (#{User.guess_email} - default):"
-          email = ask(email_question)
-          email = email.blank? ? User.guess_email : email
-          return email if email.present?
-          say_error "Email can't be blank, please try again"
-        end
-
-        def ask_for_password
-          loop do
-            say "Password: "
-            password = echo_disabled { $stdin.gets.strip }
-            say_new_line
-            say "Password confirmation: "
-            password_confirmation = echo_disabled { $stdin.gets.strip }
-            say_new_line
-            if password.present?
-              return password if password == password_confirmation
-              say "Password and password confirmation don't match, please type them again"
-            else
-              say "Password can't be blank"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/shelly/cli/apps.rb

@@ -1,90 +0,0 @@
-require "shelly/app"
-
-module Shelly
-  module CLI
-    class Apps < Thor
-      include Helpers
-      namespace :apps
-
-      desc "add", "Adds new application to Shelly Cloud"
-      def add
-        say_error "Must be run inside your project git repository" unless App.inside_git_repository?
-
-        @app = Shelly::App.new
-        @app.purpose = ask_for_purpose
-        @app.code_name = ask_for_code_name
-        @app.databases = ask_for_databases
-        @app.create
-
-        unless @app.remote_exists?
-          say "Adding remote #{@app.purpose} #{@app.git_url}", :green
-          @app.add_git_remote
-        else
-          say "Remote #{@app.purpose} already exists"
-          if yes?("Would you like to overwrite remote #{@app.purpose} with #{@app.git_url} (Y/N)?:")
-            @app.add_git_remote(true)
-          end
-        end
-
-        say "Creating Cloudfile", :green
-        @app.create_cloudfile
-
-        say "Provide billing details. Opening browser...", :green
-        @app.open_billing_page
-
-        info_adding_cloudfile_to_repository
-        info_deploying_to_shellycloud
-      rescue Client::APIError => e
-        if e.message == "Validation Failed"
-          e.errors.each { |error| say "#{error.first} #{error.last}" }
-          exit 1
-        end
-      end
-
-      no_tasks do
-        def ask_for_purpose
-          purpose = ask("How will you use this system (production - default,staging):")
-          purpose.blank? ? "production" : purpose
-        end
-
-        def ask_for_code_name
-          default_code_name = "#{Shelly::App.guess_code_name}-#{@app.purpose}"
-          code_name = ask("Application code name (#{default_code_name} - default):")
-          code_name.blank? ? default_code_name : code_name
-        end
-
-        def ask_for_databases
-          kinds = Shelly::App::DATABASE_KINDS
-          databases = ask("Which database do you want to use #{kinds.join(", ")} (postgresql - default):")
-          begin
-            databases = databases.split(/[\s,]/)
-            valid = databases.all? { |kind| kinds.include?(kind) }
-            break if valid
-            databases = ask("Unknown database kind. Supported are: #{kinds.join(", ")}:")
-          end while not valid
-
-          databases.empty? ? ["postgresql"] : databases
-        end
-
-        def info_adding_cloudfile_to_repository
-          say_new_line
-          say "Project is now configured for use with Shell Cloud:", :green
-          say "You can review changes using", :green
-          say "  git diff"
-        end
-
-        def info_deploying_to_shellycloud
-          say_new_line
-          say "When you make sure all settings are correct please issue following commands:", :green
-          say "  git add ."
-          say '  git commit -m "Application added to Shelly Cloud"'
-          say "  git push"
-          say_new_line
-          say "Deploy to #{@app.purpose} using:", :green
-          say "  git push #{@app.purpose} master"
-        end
-      end
-    end
-  end
-end
-

data/spec/shelly/cli/account_spec.rb

@@ -1,128 +0,0 @@
-require "spec_helper"
-require "shelly/cli/account"
-
-describe Shelly::CLI::Account do
-  before do
-    FileUtils.stub(:chmod)
-    @client = mock
-    @account = Shelly::CLI::Account.new
-    Shelly::Client.stub(:new).and_return(@client)
-    $stdout.stub(:puts)
-    $stdout.stub(:print)
-  end
-
-  describe "#register" do
-    before do
-      Shelly::User.stub(:guess_email).and_return("")
-      @client.stub(:register_user)
-      @key_path = File.expand_path("~/.ssh/id_rsa.pub")
-    end
-
-    it "should ask for email, password and password confirmation" do
-      $stdout.should_receive(:print).with("Email: ")
-      $stdout.should_receive(:print).with("Password: ")
-      $stdout.should_receive(:print).with("Password confirmation: ")
-      fake_stdin(["better@example.com", "secret", "secret"]) do
-        @account.register
-      end
-    end
-
-    it "should suggest email and use it if user enters blank email" do
-      Shelly::User.stub(:guess_email).and_return("kate@example.com")
-      $stdout.should_receive(:print).with("Email (kate@example.com - default): ")
-      @client.should_receive(:register_user).with("kate@example.com", "secret", nil)
-      fake_stdin(["", "secret", "secret"]) do
-        @account.register
-      end
-    end
-
-    it "should use email provided by user" do
-      @client.should_receive(:register_user).with("better@example.com", "secret", nil)
-      fake_stdin(["better@example.com", "secret", "secret"]) do
-        @account.register
-      end
-    end
-
-    it "should not ask about email if it's provided as argument" do
-      $stdout.should_receive(:puts).with("Registering with email: kate@example.com")
-      fake_stdin(["secret", "secret"]) do
-        @account.register("kate@example.com")
-      end
-    end
-
-    context "when user enters blank email" do
-      it "should show error message and exit with 1" do
-        Shelly::User.stub(:guess_email).and_return("")
-        $stdout.should_receive(:puts).with("Email can't be blank, please try again")
-        lambda {
-          fake_stdin(["", "bob@example.com", "only-pass", "only-pass"]) do
-            @account.register
-          end
-        }.should raise_error(SystemExit)
-      end
-    end
-
-    context "when user enters blank password" do
-      it "should ask for it again" do
-        $stdout.should_receive(:puts).with("Password can't be blank")
-        fake_stdin(["better@example.com", "", "", "secret", "secret"]) do
-          @account.register
-        end
-      end
-    end
-
-    context "when user enters password and password confirmation which don't match each other" do
-      it "should ask for them again" do
-        $stdout.should_receive(:puts).with("Password and password confirmation don't match, please type them again")
-        fake_stdin(["better@example.com", "secret", "sec-TYPO-ret", "secret", "secret"]) do
-          @account.register
-        end
-      end
-    end
-
-    context "public SSH key exists" do
-      it "should register with the public SSH key" do
-        FileUtils.mkdir_p("~/.ssh")
-        File.open(@key_path, "w") { |f| f << "key" }
-        $stdout.should_receive(:puts).with("Uploading your public SSH key from #{@key_path}")
-        fake_stdin(["kate@example.com", "secret", "secret"]) do
-          @account.register
-        end
-      end
-    end
-
-    context "public SSH key doesn't exist" do
-      it "should register user without the public SSH key" do
-        $stdout.should_not_receive(:puts).with("Uploading your public SSH key from #{@key_path}")
-        fake_stdin(["kate@example.com", "secret", "secret"]) do
-          @account.register
-        end
-      end
-    end
-
-    context "on successful registration" do
-      it "should display message about registration and email address confirmation" do
-        @client.stub(:register_user).and_return(true)
-        $stdout.should_receive(:puts).with("Successfully registered!")
-        $stdout.should_receive(:puts).with("Check you mailbox for email address confirmation")
-        fake_stdin(["kate@example.com", "pass", "pass"]) do
-          @account.register
-        end
-      end
-    end
-
-    context "on unsuccessful registration" do
-      it "should display errors and exit with 1" do
-        response = {"message" => "Validation Failed", "errors" => [["email", "has been already taken"]]}
-        exception = Shelly::Client::APIError.new(response)
-        @client.stub(:register_user).and_raise(exception)
-        $stdout.should_receive(:puts).with("email has been already taken")
-        lambda {
-          fake_stdin(["kate@example.com", "pass", "pass"]) do
-            @account.register
-          end
-        }.should raise_error(SystemExit)
-      end
-    end
-  end
-end

data/spec/shelly/cli/apps_spec.rb

@@ -1,192 +0,0 @@
-require "spec_helper"
-require "shelly/cli/apps"
-
-describe Shelly::CLI::Apps do
-  before do
-    @apps = Shelly::CLI::Apps.new
-    $stdout.stub(:print)
-    $stdout.stub(:puts)
-  end
-
-  describe "#add" do
-    before do
-      FileUtils.mkdir_p("/projects/foo")
-      Dir.chdir("/projects/foo")
-      @app = Shelly::App.new
-      @app.stub(:add_git_remote)
-      @app.stub(:create)
-      @app.stub(:generate_cloudfile).and_return("Example Cloudfile")
-      @app.stub(:open_billing_page)
-      @app.stub(:remote_exists?).and_return(false)
-      Shelly::App.stub(:inside_git_repository?).and_return(true)
-      Shelly::App.stub(:new).and_return(@app)
-    end
-
-    it "should exit with message if command run outside git repository" do
-      Shelly::App.stub(:inside_git_repository?).and_return(false)
-      $stdout.should_receive(:puts).with("Must be run inside your project git repository")
-      lambda {
-        fake_stdin(["staging", "", ""]) do
-          @apps.add
-        end
-      }.should raise_error(SystemExit)
-    end
-
-    it "should ask user how he will use application" do
-      $stdout.should_receive(:print).with("How will you use this system (production - default,staging): ")
-      @app.should_receive(:purpose=).with("staging")
-      fake_stdin(["staging", "", ""]) do
-        @apps.add
-      end
-    end
-
-    context "when user provided empty purpose" do
-      it "should use 'production' as default" do
-        $stdout.should_receive(:print).with("How will you use this system (production - default,staging): ")
-        @app.should_receive(:purpose=).with("production")
-        fake_stdin(["", "", ""]) do
-          @apps.add
-        end
-      end
-    end
-
-    it "should use code name provided by user" do
-      $stdout.should_receive(:print).with("How will you use this system (production - default,staging): ")
-      $stdout.should_receive(:print).with("Application code name (foo-staging - default): ")
-      @app.should_receive(:code_name=).with("mycodename")
-      fake_stdin(["staging", "mycodename", ""]) do
-        @apps.add
-      end
-    end
-
-    context "when user provided empty code name" do
-      it "should use 'current_dirname-purpose' as default" do
-        $stdout.should_receive(:print).with("How will you use this system (production - default,staging): ")
-        $stdout.should_receive(:print).with("Application code name (foo-staging - default): ")
-        fake_stdin(["staging", "", ""]) do
-          @apps.add
-        end
-      end
-    end
-
-    it "should use database provided by user (separated by comma or space)" do
-      $stdout.should_receive(:print).with("Which database do you want to use postgresql, mongodb, redis, none (postgresql - default): ")
-      @app.should_receive(:databases=).with(["postgresql", "mongodb", "redis"])
-      fake_stdin(["staging", "", "postgresql,mongodb redis"]) do
-        @apps.add
-      end
-    end
-
-    it "should ask again for databases if unsupported kind typed" do
-      $stdout.should_receive(:print).with("Which database do you want to use postgresql, mongodb, redis, none (postgresql - default): ")
-      $stdout.should_receive(:print).with("Unknown database kind. Supported are: postgresql, mongodb, redis, none: ")
-      fake_stdin(["staging", "", "postgresql,doesnt-exist", "none"]) do
-        @apps.add
-      end
-    end
-
-    context "when user provided empty database" do
-      it "should use 'postgresql' database as default" do
-        @app.should_receive(:databases=).with(["postgresql"])
-        fake_stdin(["staging", "", ""]) do
-          @apps.add
-        end
-      end
-    end
-
-    it "should create the app on shelly cloud" do
-      @app.should_receive(:create)
-      fake_stdin(["", "", ""]) do
-        @apps.add
-      end
-    end
-
-    it "should display validation errors if they are any" do
-      response = {"message" => "Validation Failed", "errors" => [["code_name", "has been already taken"]]}
-      exception = Shelly::Client::APIError.new(response)
-      @app.should_receive(:create).and_raise(exception)
-      $stdout.should_receive(:puts).with("code_name has been already taken")
-      lambda {
-        fake_stdin(["", "", ""]) do
-          @apps.add
-        end
-      }.should raise_error(SystemExit)
-    end
-
-    context "git remote doesn't exist" do
-      it "should add git remote" do
-        $stdout.should_receive(:puts).with("\e[32mAdding remote staging git@git.shellycloud.com:foooo.git\e[0m")
-        @app.should_receive(:add_git_remote)
-        fake_stdin(["staging", "foooo", ""]) do
-          @apps.add
-        end
-      end
-    end
-
-    context "git remote exist" do
-      before do
-        @app.stub(:remote_exists?).and_return(true)
-      end
-
-      it "should ask user if he wants to overwrite existing git remote" do
-        $stdout.should_receive(:puts).with("Remote staging already exists")
-        $stdout.should_receive(:print).with("Would you like to overwrite remote staging with git@git.shellycloud.com:foooo.git (Y/N)?: ")
-        fake_stdin(["staging", "foooo", "", "y"]) do
-          @apps.add
-        end
-      end
-
-      it "should overwrite existing git remote on 'yes' from user" do
-        @app.should_receive(:add_git_remote).with(true)
-        fake_stdin(["staging", "foooo", "", "y"]) do
-          @apps.add
-        end
-      end
-
-      it "should not overwrite existing git remote on 'no' from user" do
-        @app.should_not_receive(:add_git_remote).with(true)
-        fake_stdin(["staging", "foooo", "", "n"]) do
-          @apps.add
-        end
-      end
-    end
-
-    it "should create Cloudfile" do
-      File.exists?("/projects/foo/Cloudfile").should be_false
-      fake_stdin(["staging", "foooo", ""]) do
-        @apps.add
-      end
-      File.read("/projects/foo/Cloudfile").should == "Example Cloudfile"
-    end
-
-    it "should browser window with link to edit billing information" do
-      $stdout.should_receive(:puts).with("\e[32mProvide billing details. Opening browser...\e[0m")
-      @app.should_receive(:open_billing_page)
-      fake_stdin(["staging", "foooo", ""]) do
-        @apps.add
-      end
-    end
-
-    it "should display info about adding Cloudfile to repository" do
-      $stdout.should_receive(:puts).with("\e[32mProject is now configured for use with Shell Cloud:\e[0m")
-      $stdout.should_receive(:puts).with("\e[32mYou can review changes using\e[0m")
-      $stdout.should_receive(:puts).with("  git diff")
-      fake_stdin(["staging", "foooo", "none"]) do
-        @apps.add
-      end
-    end
-
-    it "should display info on how to deploy to ShellyCloud" do
-      $stdout.should_receive(:puts).with("\e[32mWhen you make sure all settings are correct please issue following commands:\e[0m")
-      $stdout.should_receive(:puts).with("  git add .")
-      $stdout.should_receive(:puts).with('  git commit -m "Application added to Shelly Cloud"')
-      $stdout.should_receive(:puts).with("  git push")
-      $stdout.should_receive(:puts).with("\e[32mDeploy to staging using:\e[0m")
-      $stdout.should_receive(:puts).with("  git push staging master")
-      fake_stdin(["staging", "foooo", "none"]) do
-        @apps.add
-      end
-    end
-  end
-end
-