shelly 0.0.1 → 0.0.2

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec', :cli => '--color --format doc' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/shelly/(.+)\.rb$})     { |m| "spec/shelly/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/README.md

@@ -0,0 +1,6 @@
+# shelly: Shelly Cloud command line tool
+
+
+### Running tests
+
+    rake spec

data/Rakefile

@@ -1 +1,7 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w(-fs --color)
+end

data/bin/shelly

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require "shelly/cli"
+Shelly::CLI.start

data/lib/core_ext/object.rb

@@ -0,0 +1,5 @@
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+end

data/lib/shelly.rb

@@ -1,5 +1,8 @@
-require "shelly/version"
+require "rubygems"
+require "thor"
+require "core_ext/object"
 
 module Shelly
-  # Your code goes here...
+  autoload :VERSION, "shelly/version"
+  autoload :Client, "shelly/client"
 end

data/lib/shelly/cli.rb

@@ -0,0 +1,33 @@
+require "shelly"
+
+module Shelly
+  class CLI < Thor
+    include Thor::Actions
+    autoload :User, "shelly/user"
+
+    map %w(-v --version) => :version
+    desc "version", "Displays shelly version"
+    def version
+      say "shelly version #{Shelly::VERSION}"
+    end
+
+    desc "register", "Registers new user at Shelly Cloud"
+    def register
+      email_question = User.guess_email.blank? ? "Email:" : "Email (default #{User.guess_email}):"
+      email = ask(email_question)
+      email = User.guess_email if email.blank?
+      password = ask("Password:")
+
+      if email.blank? or password.blank?
+        say "Email and password can't be blank" and exit 1
+      end
+
+      user = User.new(email, password)
+      say "Check you mailbox for email confirmation" if user.register
+    rescue Client::APIError => e
+      if e.message == "Validation Failed"
+        e.errors.each { |error| say "#{error.first} #{error.last}" }
+      end
+    end
+  end
+end

data/lib/shelly/client.rb

@@ -0,0 +1,78 @@
+require "rest_client"
+require "json"
+
+module Shelly
+  class Client
+    class UnauthorizedException < Exception; end
+    class UnsupportedResponseException < Exception; end
+    class APIError < Exception
+      def initialize(response)
+        @response = response
+      end
+
+      def message
+        @response["message"]
+      end
+
+      def errors
+        @response["errors"]
+      end
+    end
+
+    def initialize(email = nil, password = nil)
+      @email = email
+      @password = password
+    end
+
+    def api_url
+      ENV["SHELLY_URL"] || "https://admin.winniecloud.com/apiv2"
+    end
+
+    def register_user(email, password)
+      post('/users', :user => {:email => email, :password => password})
+    end
+
+    def post(path, params = {})
+      request(path, :post, params)
+    end
+
+    def get(path)
+      request(path, :get)
+    end
+
+    def request(path, method, params = {})
+      unless @email.blank? or @password.blank?
+        params.merge!(:email => @email, :password => @password)
+      end
+
+      RestClient::Request.execute(
+        :method   => method,
+        :url      => "#{api_url}#{path}",
+        :headers  => headers,
+        :payload  => params.to_json
+      ) { |response, request| process_response(response) }
+    end
+
+    def process_response(response)
+      raise UnauthorizedException.new if response.code == 302
+      if [404, 422, 500].include?(response.code)
+        error_details = JSON.parse(response.body)
+        raise APIError.new(error_details)
+      end
+
+      begin
+        response.return!
+        JSON.parse(response.body)
+      rescue RestClient::RequestFailed => e
+        raise UnauthorizedException.new if e.http_code == 406
+        raise UnsupportedResponseException.new(e)
+      end
+    end
+
+    def headers
+      {:accept          => :json,
+       :content_type    => :json,
+       "shelly-version" => Shelly::VERSION}
+    end
+  end
+end

data/lib/shelly/user.rb

@@ -0,0 +1,47 @@
+module Shelly
+  class User
+    attr_reader :email, :password
+    def initialize(email = nil, password = nil)
+      @email = email
+      @password = password
+    end
+
+    def register
+      client = Client.new
+      client.register_user(email, password)
+      save_credentials
+    end
+
+    def self.guess_email
+      @@guess_email ||= IO.popen("git config --get user.email").read.strip
+    end
+
+    def load_credentials
+      @email, @password = File.read(credentials_path).split("\n")
+    end
+
+    def save_credentials
+      FileUtils.mkdir_p(config_dir) unless credentials_exists?
+      File.open(credentials_path, 'w') { |file| file << "#{email}\n#{password}" }
+      set_credentials_permissions
+    end
+
+    protected
+      def config_dir
+        File.expand_path("~/.shelly")
+      end
+
+      def credentials_path
+        File.join(config_dir, "credentials")
+      end
+
+      def credentials_exists?
+        File.exists?(credentials_path)
+      end
+
+      def set_credentials_permissions
+        FileUtils.chmod(0700, config_dir)
+        FileUtils.chmod(0600, credentials_path)
+      end
+    end
+end

data/lib/shelly/version.rb

@@ -1,3 +1,3 @@
 module Shelly
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/shelly.gemspec

@@ -12,13 +12,20 @@ Gem::Specification.new do |s|
   s.description = %q{Tool for managing applications and clouds at shellycloud.com}
 
   s.rubyforge_project = "shelly"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-rspec"
+  if RUBY_PLATFORM =~ /darwin/
+    s.add_development_dependency "growl_notify"
+    s.add_development_dependency "rb-fsevent"
+  end
+  s.add_development_dependency "fakefs"
+  s.add_runtime_dependency "thor"
+  s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency "json"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-
-  # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
 end

data/spec/helpers.rb

@@ -0,0 +1,7 @@
+module RSpec
+  module Helpers
+    def fake_stdin(strings)
+      InputFaker.with_fake_input(strings) { yield }
+    end
+  end
+end

data/spec/input_faker.rb

@@ -0,0 +1,19 @@
+class InputFaker
+  def initialize(strings)
+    @strings = strings
+  end
+
+  def gets
+    next_string = @strings.shift
+    # Uncomment the following line if you'd like to see the faked $stdin#gets
+    # puts "(DEBUG) Faking #gets with: #{next_string}"
+    next_string
+  end
+
+  def self.with_fake_input(strings)
+    $stdin = new(strings)
+    yield
+  ensure
+    $stdin = STDIN
+  end
+end

data/spec/io_ext.rb

@@ -0,0 +1,5 @@
+class IO
+  def read_available_bytes
+    readpartial(100000)
+  end
+end

data/spec/shelly/cli_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+require "shelly/cli"
+require "shelly/user"
+
+describe Shelly::CLI do
+  before do
+    @client = mock
+    @cli = Shelly::CLI.new
+    Shelly::Client.stub(:new).and_return(@client)
+    $stdout.stub(:puts)
+    $stdout.stub(:print)
+  end
+
+  describe "#version" do
+    it "should return shelly's version" do
+      $stdout.should_receive(:puts).with("shelly version #{Shelly::VERSION}")
+      @cli.version
+    end
+  end
+
+  describe "#register" do
+    before do
+      Shelly::User.stub(:guess_email).and_return("")
+      @client.stub(:register_user)
+    end
+
+    it "should ask for email and password" do
+      $stdout.should_receive(:print).with("Email: ")
+      $stdout.should_receive(:print).with("Password: ")
+      fake_stdin(["better@example.com", "secret"]) do
+        @cli.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 (default kate@example.com): ")
+      @client.should_receive(:register_user).with("kate@example.com", "secret")
+      fake_stdin(["", "secret"]) do
+        @cli.register
+      end
+    end
+
+    it "should use email provided by user" do
+      @client.should_receive(:register_user).with("better@example.com", "secret")
+      fake_stdin(["better@example.com", "secret"]) do
+        @cli.register
+      end
+    end
+
+    it "should exit with message if email is blank" do
+      Shelly::User.stub(:guess_email).and_return("")
+      $stdout.should_receive(:puts).with("Email and password can't be blank")
+      lambda do
+        fake_stdin(["", "only-pass"]) do
+          @cli.register
+        end
+      end.should raise_error(SystemExit)
+    end
+
+    it "should exit with message if password is blank" do
+      $stdout.should_receive(:puts).with("Email and password can't be blank")
+      lambda do
+        fake_stdin(["better@example.com", ""]) do
+          @cli.register
+        end
+      end.should raise_error(SystemExit)
+    end
+
+    context "on successful registration" do
+      it "should notify user about email verification" do
+        @client.stub(:register_user).and_return(true)
+        $stdout.should_receive(:puts).with("Check you mailbox for email confirmation")
+        fake_stdin(["kate@example.com", "pass"]) do
+          @cli.register
+        end
+      end
+    end
+
+    context "on unsuccessful registration" do
+      it "should notify user about errors" 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")
+        fake_stdin(["kate@example.com", "pass"]) do
+          @cli.register
+        end
+      end
+    end
+  end
+end

data/spec/shelly/client_spec.rb

@@ -0,0 +1,151 @@
+require "spec_helper"
+
+describe Shelly::Client do
+  before do
+    ENV['SHELLY_URL'] = nil
+    @client = Shelly::Client.new("bob@example.com", "secret")
+    RestClient::Request.stub!(:execute)
+  end
+
+  describe "#api_url" do
+    context "env SHELLY_URL is not set" do
+      it "should return default API URL" do
+        ENV['SHELLY_URL'].should be_nil
+        @client.api_url.should == "https://admin.winniecloud.com/apiv2"
+      end
+    end
+
+    context "env variable SHELLY_URL is set" do
+      it "should return value of env variable SHELLY_URL" do
+        ENV['SHELLY_URL'] = "https://example.com/api"
+        @client.api_url.should == "https://example.com/api"
+      end
+    end
+  end
+
+  describe "#request" do
+    it "should make a request to given URL" do
+      RestClient::Request.should_receive(:execute).with(
+        request_parameters("/account", :get)
+      )
+      @client.request("/account", :get)
+    end
+
+    it "should include provided parameters in the request" do
+      RestClient::Request.should_receive(:execute).with(
+        request_parameters("/account", :post, {:name => "test"})
+      )
+      @client.request("/account", :post, :name => "test")
+    end
+
+    it "should include user credentials in the request parameters" do
+      @client = Shelly::Client.new("megan-fox@example.com", "secret")
+      RestClient::Request.should_receive(:execute).with(
+        request_parameters("/account", :get, {:email => "megan-fox@example.com", :password => "secret"})
+      )
+      @client.request("/account", :get)
+    end
+
+    it "should not include user credentials when they are blank" do
+      @client = Shelly::Client.new
+      RestClient::Request.should_receive(:execute).with(
+        :method  => :get,
+        :url     => "https://admin.winniecloud.com/apiv2/account",
+        :headers => {:accept => :json, :content_type => :json, "shelly-version" => Shelly::VERSION},
+        :payload => "{}"
+      )
+      @client.request("/account", :get)
+    end
+
+    it "should pass response to process_response method" do
+      response = mock(RestClient::Response)
+      request = mock(RestClient::Request)
+      @client.should_receive(:process_response).with(response)
+      RestClient::Request.should_receive(:execute).with(
+        request_parameters("/account", :get)
+      ).and_yield(response, request)
+
+      @client.request("/account", :get)
+    end
+
+    def request_parameters(path, method, payload = {})
+       {:method  => method,
+        :url     => "https://admin.winniecloud.com/apiv2#{path}",
+        :headers => {:accept => :json, :content_type => :json, "shelly-version" => Shelly::VERSION},
+        :payload => ({:email => "bob@example.com", :password => "secret"}.merge(payload)).to_json}
+    end
+  end
+
+  describe "#process_response" do
+    before do
+      @response = mock(RestClient::Response, :code => 200, :body => "{}", :return! => nil)
+      @request = mock(RestClient::Request)
+      RestClient::Request.stub(:execute).and_yield(@response, @request)
+    end
+
+    it "should not follow redirections" do
+      @response.should_receive(:return!)
+      @client.get('/account')
+    end
+
+    context "on 302 response code" do
+      it "should raise UnauthorizedException" do
+        @response.stub(:code).and_return(302)
+        lambda {
+          @client.get("/account")
+          }.should raise_error(Shelly::Client::UnauthorizedException)
+      end
+    end
+
+    context "on 406 response code" do
+      it "should raise UnauthorizedException" do
+        exception = RestClient::RequestFailed.new
+        exception.stub(:http_code).and_return(406)
+        @response.should_receive(:return!).and_raise(exception)
+
+        lambda {
+          @client.get("/account")
+        }.should raise_error(Shelly::Client::UnauthorizedException)
+      end
+    end
+
+    %w(404 422 500).each do |code|
+      context "on #{code} response code" do
+        it "should raise APIError" do
+          @response.stub(:code).and_return(code.to_i)
+          @response.stub(:body).and_return({"message" => "random error happened"}.to_json)
+
+          lambda {
+            @client.post("/api/apps/flower/command", :body => "puts User.count")
+          }.should raise_error(Shelly::Client::APIError, "random error happened")
+        end
+      end
+    end
+
+    context "on unsupported response code" do
+      it "should raise UnsupportedResponseException exception" do
+        exception = RestClient::RequestFailed.new
+        exception.stub(:http_code).and_return(409)
+        @response.should_receive(:return!).and_raise(exception)
+
+        lambda {
+          @client.get("/account")
+        }.should raise_error(Shelly::Client::UnsupportedResponseException)
+      end
+    end
+  end
+
+  describe "#get" do
+    it "should make GET request to given path" do
+      @client.should_receive(:request).with("/account", :get)
+      @client.get("/account")
+    end
+  end
+
+  describe "#post" do
+    it "should make POST request to given path with parameters" do
+      @client.should_receive(:request).with("/account", :post, :name => "pink-one")
+      @client.post("/account", :name => "pink-one")
+    end
+  end
+end

data/spec/shelly/user_spec.rb

@@ -0,0 +1,70 @@
+require "shelly/user"
+require "spec_helper"
+
+describe Shelly::User do
+  include FakeFS::SpecHelpers
+
+  before do
+    @client = mock
+    Shelly::Client.stub(:new).and_return(@client)
+    @user = Shelly::User.new("bob@example.com", "secret")
+    @user.stub(:set_credentials_permissions)
+  end
+
+  describe ".guess_email" do
+    it "should return user email fetched from git config" do
+      io = mock(:read => "boby@example.com\n")
+      IO.should_receive(:popen).with("git config --get user.email").and_return(io)
+      Shelly::User.guess_email.should == "boby@example.com"
+    end
+  end
+
+  describe "#register" do
+    before do
+      @client.stub(:register_user)
+    end
+
+    it "should register user at Shelly Cloud" do
+      @client.should_receive(:register_user).with("bob@example.com", "secret")
+      @user.register
+    end
+
+    it "should save credentials after successful registration" do
+      @user.should_receive(:save_credentials)
+      @user.register
+    end
+  end
+
+  describe "#save_credentials" do
+    it "should save credentials to file" do
+      File.exists?("~/.shelly/credentials").should be_false
+      @user.save_credentials
+      File.read("~/.shelly/credentials").should == "bob@example.com\nsecret"
+    end
+
+    it "should create config_dir if doesn't exist" do
+      File.exists?("~/.shelly").should be_false
+      @user.save_credentials
+      File.exists?("~/.shelly").should be_true
+    end
+
+    it "should set proper permissions on config_dir and credentials file" do
+      user = Shelly::User.new("bob@example.com", "secret")
+      FileUtils.should_receive(:chmod).with(0700, File.expand_path("~/.shelly"))
+      FileUtils.should_receive(:chmod).with(0600, File.expand_path("~/.shelly/credentials"))
+      user.save_credentials
+    end
+  end
+
+  describe "#load_credentials" do
+    it "should load credentials from file" do
+      config_dir = File.expand_path("~/.shelly")
+      FileUtils.mkdir_p(config_dir)
+      File.open(File.join(config_dir, "credentials"), "w") { |f| f << "superman@example.com\nkal-el" }
+      user = Shelly::User.new
+      user.load_credentials
+      user.email.should == "superman@example.com"
+      user.password.should == "kal-el"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require "rspec"
+require "helpers"
+require "shelly"
+require "io_ext"
+require "input_faker"
+require "fakefs/safe"
+require "fakefs/spec_helpers"
+
+RSpec.configure do |config|
+  config.include RSpec::Helpers
+end

metadata

@@ -1,8 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: shelly
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.0.1
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Shelly Cloud team
@@ -10,14 +15,140 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-07 00:00:00 Z
-dependencies: []
-
+date: 2011-09-13 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: guard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: guard-rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: growl_notify
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rb-fsevent
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: fakefs
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id009
 description: Tool for managing applications and clouds at shellycloud.com
 email: 
 - support@shellycloud.com
-executables: []
-
+executables: 
+- shelly
 extensions: []
 
 extra_rdoc_files: []
@@ -25,10 +156,25 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- Guardfile
+- README.md
 - Rakefile
+- bin/shelly
+- lib/core_ext/object.rb
 - lib/shelly.rb
+- lib/shelly/cli.rb
+- lib/shelly/client.rb
+- lib/shelly/user.rb
 - lib/shelly/version.rb
 - shelly.gemspec
+- spec/helpers.rb
+- spec/input_faker.rb
+- spec/io_ext.rb
+- spec/shelly/cli_spec.rb
+- spec/shelly/client_spec.rb
+- spec/shelly/user_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
 homepage: http://shellycloud.com
 licenses: []
 
@@ -42,19 +188,31 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: shelly
-rubygems_version: 1.8.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Shelly Cloud command line tool
-test_files: []
-
+test_files: 
+- spec/helpers.rb
+- spec/input_faker.rb
+- spec/io_ext.rb
+- spec/shelly/cli_spec.rb
+- spec/shelly/client_spec.rb
+- spec/shelly/user_spec.rb
+- spec/spec_helper.rb