ey_services_api 0.3.3 → 0.3.4

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2

data/EYIntegratedGemfile

@@ -4,7 +4,7 @@ source "http://rubygems.org"
 gemspec
 
 group :test, :development do
-  gem 'ey_services_fake'
+  gemspec :path => "fake"
   gem 'rake'
 
   #private Gem deps of fake_awsm

data/Gemfile

@@ -4,9 +4,8 @@ source "http://rubygems.org"
 gemspec
 
 group :test, :development do
-  gem 'ey_services_fake'
+  gemspec :path => "fake"
 
   gem 'rake'
-  gem 'rcov'
   gem 'guard-rspec'
 end

data/fake/ey_services_fake.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ey_services_fake/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ey_services_fake"
+  s.version     = EyServicesFake::VERSION
+  s.authors     = ["Jacob Burkhart & Josh Lane"]
+  s.email       = ["jacob@engineyard.com"]
+  s.homepage    = ""
+  s.summary     = %q{A fake for use when writting tests against the ey_services_api}
+  s.description = %q{A fake for use when writting tests against the ey_services_api}
+
+  s.rubyforge_project = "ey_services_fake"
+
+  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"]
+
+  s.add_dependency "sinatra"
+  s.add_dependency "cubbyhole", ">= 0.2.0"
+end

data/fake/lib/ey_services_fake/mock_backend.rb

@@ -0,0 +1,158 @@
+module EyServicesFake
+  class MockBackend
+
+    def self.tresfiestas_fake
+      require 'ey_services_fake/tresfiestas_fake'
+      TresfiestasFake
+    end
+
+    def self.setup!(actors = {})
+      unless actors[:awsm]
+        require 'ey_services_fake/reacharound_awsm'
+        actors[:awsm] = ReacharoundAwsm.new
+      end
+      unless actors[:service_provider]
+        require 'ey_services_fake/mocking_bird_service'
+        actors[:service_provider] = MockingBirdService.new
+      end
+      unless actors[:tresfiestas]
+        actors[:tresfiestas] = tresfiestas_fake.new
+      end
+      new(actors)
+    end
+
+    def initialize(actors)
+      @actors = actors
+    end
+
+    def actor(role)
+      @actors[role] or raise "No actor registered as #{role}, I have #{@actors.keys.inspect}"
+    end
+
+    def reset!
+      @actors.values.each do |v|
+        v.reset!
+      end
+    end
+
+    def awsm
+      awsm_hash = actor(:tresfiestas).find_awsm
+      unless awsm_hash
+        awsm_hash = actor(:tresfiestas).create_awsm(actor(:awsm).base_url, actor(:awsm).app)
+        actor(:awsm).setup(awsm_hash[:auth_id], awsm_hash[:auth_key], actor(:tresfiestas).base_url, actor(:tresfiestas).app)
+      end
+      awsm_hash
+    end
+
+    def partner
+      partner_hash = actor(:tresfiestas).find_partner(sso_user)
+      unless partner_hash
+        partner_hash = actor(:tresfiestas).create_partner(sso_user, actor(:service_provider).base_url, actor(:service_provider).app)
+        @actors.values.each do |actor|
+          if actor.respond_to?(:service_provider_setup)
+            actor.service_provider_setup(partner_hash[:auth_id], partner_hash[:auth_key], actor(:service_provider).base_url, actor(:service_provider).app)
+          end
+        end
+        actor(:service_provider).setup(partner_hash[:auth_id], partner_hash[:auth_key], actor(:tresfiestas).base_url, actor(:tresfiestas).app)
+      end
+      partner_hash
+    end
+
+    def service
+      partner_hash = self.partner
+      service_hash = actor(:tresfiestas).find_service(partner_hash[:id])
+      unless service_hash
+        actor(:service_provider).register_service(partner_hash[:registration_url])
+        service_hash = actor(:tresfiestas).find_service(partner_hash[:id])
+      end
+      if actor(:tresfiestas).respond_to?(:document_service)
+        service_hash.merge!(:service_doc => actor(:tresfiestas).document_service(service_hash[:id]))
+      end
+      service_hash.merge(:partner => partner_hash)
+    end
+
+    def sso_user
+      actor(:awsm).sso_user #allows for nils (some implementations of AWSM may decide this is ok)
+    end
+
+    def sso_account
+      awsm #need to have setup awsm before you can create accounts!
+      sso_user_something = sso_user #the sso_user is a somehting, not necessarily a hash
+      sso_account_hash = actor(:awsm).find_sso_account(sso_user_something)
+      unless sso_account_hash
+        sso_account_hash = actor(:awsm).create_sso_account(sso_user_something)
+      end
+      sso_account_hash
+    end
+
+    def service_enablement
+      sso_account_hash = self.sso_account
+      service_hash = self.service
+      unless actor(:tresfiestas).service_available_for_account?(service_hash[:id], sso_account_hash[:id])
+        actor(:tresfiestas).make_service_available_for_account(service_hash[:id], sso_account_hash[:id])
+      end
+      {
+        :service => service_hash,
+        :sso_account => sso_account_hash,
+      }
+    end
+
+    def service_account
+      service_enablement_hash = self.service_enablement
+      sso_account_hash = service_enablement_hash[:sso_account]
+      service_hash = service_enablement_hash[:service]
+      service_account_hash = actor(:tresfiestas).find_service_account(service_hash[:id], sso_account_hash[:id])
+      unless service_account_hash
+        actor(:awsm).enable_service(service_hash[:id], sso_account_hash[:id])
+        service_account_hash = actor(:tresfiestas).find_service_account(service_hash[:id], sso_account_hash[:id])
+      end
+      service_account_hash.merge(:name => sso_account_hash[:name], :service => service_hash, :sso_account => sso_account_hash)
+    end
+
+    def destroy_service_account
+      actor(:awsm).disable_service(service_account[:id])
+    end
+
+    def app_deployment
+      app_deployment_hash = actor(:awsm).find_app_deployment(sso_account[:id])
+      unless app_deployment_hash
+        actor(:awsm).create_app_deployment(sso_account[:id], "myapp", "myenv", "production")
+        app_deployment_hash = actor(:awsm).find_app_deployment(sso_account[:id])
+      end
+      app_deployment_hash
+    end
+
+    def provisioned_service
+      service_account_hash = self.service_account
+      sso_account_hash = service_account_hash[:sso_account]
+      app_deployment_hash = self.app_deployment
+      provisioned_service_hash = actor(:tresfiestas).find_provisioned_service(service_account_hash[:id], app_deployment_hash[:id])
+      unless provisioned_service_hash
+        actor(:awsm).provision_service(sso_account_hash[:id], service_account_hash[:id], app_deployment_hash[:id])
+        provisioned_service_hash = actor(:tresfiestas).find_provisioned_service(service_account_hash[:id], app_deployment_hash[:id])
+      end
+      provisioned_service_hash.merge(:service_account => service_account_hash, :app_deployment => app_deployment_hash)
+    end
+
+    def destroy_provisioned_service
+      actor(:awsm).deprovision_service(provisioned_service[:id])
+    end
+
+    def latest_invoice
+      actor(:tresfiestas).latest_invoice
+    end
+
+    def latest_status_message
+      actor(:tresfiestas).latest_status_message
+    end
+
+    def send_message(message_url, message_type, message_subject, message_body = nil)
+      actor(:service_provider).send_message(message_url, message_type, message_subject, message_body)
+    end
+
+    def send_invoice(invoices_url, total_amount_cent, line_item_description)
+      actor(:service_provider).send_invoice(invoices_url, total_amount_cent, line_item_description)
+    end
+
+  end
+end

data/fake/lib/ey_services_fake/mocking_bird_service.rb

@@ -0,0 +1,155 @@
+require 'sinatra/base'
+
+module EyServicesFake
+  class MockingBirdService
+    class Application < Sinatra::Base
+      enable :raise_errors
+      disable :dump_errors
+      disable :show_exceptions
+
+      delete '/api/1/some_provisioned_service' do
+        if MockingBirdService.service_deprovisioning_handler
+          instance_eval(&MockingBirdService.service_deprovisioning_handler)
+        else
+          {}.to_json
+        end
+      end
+
+      delete '/api/1/some_service_account' do
+        if MockingBirdService.service_account_cancel_handler
+          instance_eval(&MockingBirdService.service_account_cancel_handler)
+        else
+          {}.to_json
+        end
+      end
+
+      post '/api/1/service_accounts_callback' do
+        if MockingBirdService.service_account_creation_handler
+          instance_eval(&MockingBirdService.service_account_creation_handler)
+        else
+          service_account = EY::ServicesAPI::ServiceAccountCreation.from_request(request.body.read)
+          standard_response_params = MockingBirdService.service_account_creation_params
+          EY::ServicesAPI::ServiceAccountResponse.new(
+            :provisioned_services_url => standard_response_params[:provisioned_services_url],
+            :url                      => standard_response_params[:url],
+            :configuration_url        => standard_response_params[:configuration_url],
+            :configuration_required   => standard_response_params[:configuration_required],
+            :message                  => EY::ServicesAPI::Message.new(:message_type => "status", :subject => "some messages")
+          ).to_hash.to_json
+        end
+      end
+
+      post '/api/1/provisioned_services_callback' do
+        if MockingBirdService.service_provisioning_handler
+          instance_eval(&MockingBirdService.service_provisioning_handler)
+        else
+          provisioned_service = EY::ServicesAPI::ProvisionedServiceCreation.from_request(request.body.read)
+          standard_response_params = MockingBirdService.service_provisioned_params
+          EY::ServicesAPI::ProvisionedServiceResponse.new(
+            :url                    => standard_response_params[:url],
+            :vars                   => standard_response_params[:vars],
+            :configuration_required => false,
+            :configuration_url      => standard_response_params[:configuration_url],
+            :message                => EY::ServicesAPI::Message.new(:message_type => "status", :subject => "some provisioned service messages")
+          ).to_hash.to_json
+        end
+      end
+
+      get '/sso/some_service_account' do
+        "SSO Hello Service Account"
+      end
+
+      get '/sso/some_provisioned_service' do
+        "SSO Hello Provisioned Service"
+      end
+    end
+
+    class << self
+      attr_accessor :service_account_creation_handler
+      attr_accessor :service_provisioning_handler
+      attr_accessor :service_deprovisioning_handler
+      attr_accessor :service_account_cancel_handler
+    end
+
+    def reset!
+      MockingBirdService.service_account_creation_handler = nil
+      MockingBirdService.service_provisioning_handler = nil
+      MockingBirdService.service_deprovisioning_handler = nil
+      MockingBirdService.service_account_cancel_handler = nil
+    end
+
+    def app
+      Application
+    end
+
+    def setup(auth_id, auth_key, base_url = nil, backend = nil)
+      require 'ey_services_api'
+      connection = EY::ServicesAPI.setup!(:auth_id => auth_id, :auth_key => auth_key)
+      if backend
+        connection.backend = backend
+      end
+    end
+
+    def base_url
+      self.class.base_url
+    end
+    def self.base_url
+      "http://mock.service/"
+    end
+
+    def registration_params
+      self.class.registration_params
+    end
+    def self.registration_params
+      {
+        :name => "Mocking Bird",
+        :label => "mocking_bird",
+        :description => "a mock service",
+        :service_accounts_url =>     "#{base_url}api/1/service_accounts_callback",
+        :home_url =>                 "#{base_url}",
+        :terms_and_conditions_url => "#{base_url}terms",
+        :vars => ["some_var", "other_var"]
+      }
+    end
+
+    def service_account_creation_params
+      self.class.service_account_creation_params
+    end
+    def self.service_account_creation_params
+      {
+        :provisioned_services_url => "#{base_url}api/1/provisioned_services_callback",
+        :url => "#{base_url}api/1/some_service_account",
+        :configuration_url => "#{base_url}sso/some_service_account",
+        :configuration_required => false
+      }
+    end
+
+    def service_provisioned_params
+      self.class.service_provisioned_params
+    end
+    def self.service_provisioned_params
+      {
+        :vars => {"some_var" => "value", "other_var" => "blah"},
+        :configuration_url => "#{base_url}sso/some_provisioned_service",
+        :configuration_required => false,
+        :url => "#{base_url}api/1/some_provisioned_service",
+      }
+    end
+
+    def register_service(registration_url)
+      EY::ServicesAPI.connection.register_service(registration_url, MockingBirdService.registration_params)
+    end
+
+    def send_message(message_url, message_type, message_subject, message_body)
+      message = EY::ServicesAPI::Message.new(:message_type => message_type, :subject => message_subject, :body => message_body)
+      EY::ServicesAPI.connection.send_message(message_url, message)
+    end
+
+    def send_invoice(invoices_url, total_amount_cent, line_item_description)
+      invoice = EY::ServicesAPI::Invoice.new(:total_amount_cents => total_amount_cent,
+                                             :line_item_description => line_item_description)
+      EY::ServicesAPI.connection.send_invoice(invoices_url, invoice)
+    end
+
+  end
+end

data/fake/lib/ey_services_fake/models.rb

@@ -0,0 +1,74 @@
+require 'cubbyhole/base'
+
+module EyServicesFake
+  class Model < Cubbyhole::Base
+    def self.inherited(klass)
+      decendants << klass
+    end
+    class << self
+      attr_accessor :current_id
+    end
+    self.current_id = 0
+    def self.next_id
+      Model.current_id += 1
+    end
+    def self.nuke_all
+      decendants.map(&:nuke)
+    end
+    def self.backend
+      @backend ||= Hash.new
+    end
+    def self.decendants
+      @decendants ||= []
+    end
+    def self.belongs_to(model, name, key)
+      search_context = self.to_s.split("::")
+      search_context.pop
+      search_context = eval(search_context.join("::").to_s)
+      self.class_eval do
+        define_method(name) do
+          klass = search_context.const_get(model)
+          klass.all.find{|s| self.send(key).to_i == s.id.to_i }
+        end
+      end
+    end
+    def self.has_many(model, name, key)
+      search_context = self.to_s.split("::")
+      search_context.pop
+      search_context = eval(search_context.join("::").to_s)
+      self.class_eval do
+        define_method(name) do
+          klass = search_context.const_get(model)
+          Cubbyhole::Collection.new(klass.all.select{|s| s.send(key).to_s == self.id.to_s })
+        end
+      end
+    end
+  end
+  class Partner < Model
+    has_many :Service, :services, :partner_id
+  end
+  class Service < Model
+    has_many :ServiceEnablement, :service_enablements, :service_id
+    has_many :ServiceAccount, :service_accounts, :service_id
+    belongs_to :Partner, :partner, :partner_id
+  end
+  class ServiceAccount < Model
+    has_many :ProvisionedService, :provisioned_services, :service_account_id
+    has_many :Message, :messages, :service_account_id
+    belongs_to :Service, :service, :service_id
+    has_many :Invoice, :invoices, :service_account_id
+  end
+  class ProvisionedService < Model
+    has_many :Message, :messages, :provisioned_service_id
+    belongs_to :ServiceAccount, :service_account, :service_account_id
+  end
+  class ServiceEnablement < Model; end
+  class Invoice < Model
+    belongs_to :ServiceAccount, :service_account, :service_account_id
+  end
+  class Message < Model
+    belongs_to :ServiceAccount, :service_account, :service_account_id
+    belongs_to :ProvisionedService, :provisioned_service, :provisioned_service_id
+  end
+  class Awsm < Model; end
+end

data/fake/lib/ey_services_fake/reacharound_awsm.rb

@@ -0,0 +1,162 @@
+require 'sinatra/base'
+require 'ey_services_fake/models'
+
+module EyServicesFake
+  class ReacharoundAwsm
+    class Application < Sinatra::Base
+      enable :raise_errors
+      disable :dump_errors
+      disable :show_exceptions
+
+      post '/dashboard_notifications_url' do
+        {}.to_json
+      end
+
+    end
+
+    def app
+      Application
+    end
+
+    def reset!
+      #no-op
+    end
+
+    def base_url
+      "http://cloud.engineyard.com"
+    end
+
+    class Account < EyServicesFake::Model; end
+    class AppDeployment < EyServicesFake::Model
+      belongs_to :App, :app, :app_id
+      belongs_to :Environment, :environment, :environment_id
+    end
+    class App < EyServicesFake::Model; end
+    class Environment < EyServicesFake::Model; end
+    class User < EyServicesFake::Model
+      has_many :Account, :accounts, :owner_id
+    end
+
+    def service_provider_setup(auth_id, auth_key, service_provider_url, service_provider_rackapp)
+      @connection = EY::ApiHMAC::AuthedConnection.new(auth_id, auth_key).tap{|c| c.backend = service_provider_rackapp}
+    end
+    def setup(auth_id, auth_key, tresfiestas_url, tresfiestas_rackapp)
+      #ignored... we don't talk to tresfiestas, we talk to service_provider
+    end
+
+    def sso_user
+      the_one_email = "the-one-user@example.com"
+      User.first(:email => the_one_email) || User.create(:email => the_one_email)
+    end
+
+    def find_sso_account(sso_user)
+      account = sso_user.accounts.first
+      account && {
+        :id => account.id,
+        :name => account.name,
+      }
+    end
+    def create_sso_account(sso_user)
+      Account.create(:owner_id => sso_user.id, :name => 'some-account')
+      find_sso_account(sso_user)
+    end
+
+    def find_app_deployment(sso_account_id)
+      app_deployment = AppDeployment.first(:account_id => sso_account_id)
+      app_deployment && {
+        :id => app_deployment.id,
+        :app => {
+          :id => app_deployment.app.id,
+          :name => app_deployment.app.name,
+        },
+        :environment => {
+          :id => app_deployment.environment.id,
+          :name => app_deployment.environment.name,
+          :framework_env => app_deployment.environment.framework_env,
+          :aws_region => app_deployment.environment.aws_region
+        }
+      }
+    end
+    def create_app_deployment(sso_account_id, app_name, env_name, framework_env)
+      app = App.create(:name => app_name)
+      env = Environment.create(:name => env_name, :framework_env => framework_env, :aws_region => 'us-east-1')
+      AppDeployment.create(:account_id => sso_account_id, :app_id => app.id, :environment_id => env.id)
+    end
+
+    #Normal implmentations of AWSM would not be posting to service_accounts_url;
+    #they would be posting to private API to say that they wish to create a service account
+    #but this is reacharound AWSM, and so it plays the role of tresfiestas internals here
+    # def enable_service(connection, sso_account, service_hash)
+    def enable_service(service_id, sso_account_id)
+      url_gen = EyServicesFake::URL_GEN
+      service_account = ServiceAccount.create(:sso_account_id => sso_account_id, :active => false, :service_id => service_id, :dashboard_notifications_url => "#{base_url}/dashboard_notifications_url")
+      service = Service.get(service_id)
+      creation_attributes = {
+        :name           => Account.get(sso_account_id).name,
+        :url            => url_gen.partner_service_account(service, service_account),
+        :messages_url   => url_gen.messages(service, service_account),
+        :invoices_url   => url_gen.invoices(service, service_account),
+      }
+      @connection.post(service.service_accounts_url, creation_attributes) do |result, location|
+        service_account.active = true
+        if result["service_account"]
+          service_account.provisioned_services_url = result["service_account"]['provisioned_services_url']
+          service_account.configuration_url = result["service_account"]['configuration_url']
+          service_account.url = result["service_account"]['url']
+          service_account.configuration_required = result["service_account"]['configuration_required']
+        end
+        if result["message"] && result["message"]["message_type"]
+          Message.create(
+            :service_account_id => service_account.id,
+            :message_type => result["message"]["message_type"],
+            :subject => result["message"]["subject"],
+            :body => result["message"]["body"])
+        end
+        service_account.save
+      end
+    end
+
+    def disable_service(service_account_id)
+      service_account = ServiceAccount.get(service_account_id)
+      @connection.delete(service_account.url)
+    end
+
+    def provision_service(sso_account_id, service_account_id, app_deployment_id)
+      url_gen = EyServicesFake::URL_GEN
+      provisioned_service = ProvisionedService.create(:app_deployment_id => app_deployment_id.to_i, :active => false, :service_account_id => service_account_id.to_i, :dashboard_notifications_url => "#{base_url}/dashboard_notifications_url")
+      service_account_object = ServiceAccount.get(service_account_id)
+      app_deployment = AppDeployment.get(app_deployment_id)
+      app = app_deployment.app
+      environment = app_deployment.environment
+      provision_attribtues = {
+        :url          => url_gen.partner_provisioned_service(service_account_object, provisioned_service),
+        :messages_url => url_gen.messages(service_account_object.service, service_account_object, provisioned_service),
+        :app          => {:id => app.id, :name => app.name},
+        :environment  => {:id => environment.id, :name => environment.name, :framework_env => environment.framework_env, :aws_region => environment.aws_region},
+      }
+      @connection.post(service_account_object.provisioned_services_url, provision_attribtues) do |result, location|
+        provisioned_service.active = true
+        if result['provisioned_service']
+          provisioned_service.vars = result['provisioned_service']["vars"]
+          provisioned_service.configuration_url = result['provisioned_service']["configuration_url"]
+          provisioned_service.configuration_required = result['provisioned_service']["configuration_required"]
+          provisioned_service.url = result['provisioned_service']["url"]
+          if result["message"] && result["message"]["message_type"]
+            Message.create(
+              :provisioned_service_id => provisioned_service.id,
+              :message_type => result["message"]["message_type"],
+              :subject => result["message"]["subject"],
+              :body => result["message"]["body"])
+          end
+        end
+        provisioned_service.save
+      end
+    end
+
+    def deprovision_service(provisioned_service_id)
+      provisioned_service = ProvisionedService.get(provisioned_service_id)
+      @connection.delete(provisioned_service.url)
+    end
+
+  end
+end

data/fake/lib/ey_services_fake/tresfiestas_fake.rb

@@ -0,0 +1,137 @@
+require 'ey_services_fake/url_generator'
+require 'ey_services_fake/models'
+require 'ey_services_fake/tresfiestas_fake_rack_app'
+
+module EyServicesFake
+  BASE_URL = "http://services.engineyard.com"
+  URL_GEN = EyServicesFake::UrlGenerator.new(BASE_URL)
+
+  class TresfiestasFake
+
+    def reset!
+      Model.nuke_all
+    end
+
+    def base_url
+      BASE_URL
+    end
+
+    def app
+      TresfiestasFakeRackApp
+    end
+
+    def find_awsm
+      awsm_object = Awsm.first
+      awsm_object && {
+        :id => awsm_object.id,
+        :auth_id => awsm_object.auth_id,
+        :auth_key => awsm_object.auth_key,
+      }
+    end
+
+    def create_awsm(awsm_base_url, awsm_app)
+      Awsm.create(:auth_id => "789eef", :auth_key => "009abb")
+      app.awsm_connection = EY::ApiHMAC::AuthedConnection.new("789eef", "009abb")
+      app.awsm_connection.backend = awsm_app
+      find_awsm
+    end
+
+    def find_partner(sso_user)
+      partner_object = Partner.first
+      partner_object && {
+        :id => partner_object.id,
+        :name => partner_object.name,
+        :auth_id => partner_object.auth_id,
+        :auth_key => partner_object.auth_key,
+        :registration_url => URL_GEN.service_registration(partner_object),
+      }
+    end
+
+    def create_partner(sso_user, partner_base_url, partner_app)
+      Partner.create(:auth_id => "123edf", :auth_key => "abc456", :name => "Some-Partner")
+      app.partner_connection = EY::ApiHMAC::AuthedConnection.new("123edf", "abc456")
+      app.partner_connection.backend = partner_app
+      find_partner(sso_user)
+    end
+
+    def find_service(partner_id)
+      partner_object = Partner.get!(partner_id)
+      service_object = partner_object.services.first
+      service_object && {
+        :id => service_object.id,
+        :name => service_object.name,
+        :label => service_object.label,
+        :revenue_share => service_object.revenue_share,
+        :service_accounts_url => service_object.service_accounts_url
+      }
+    end
+
+    def service_available_for_account?(service_id, sso_account_id)
+      Service.get(service_id).service_enablements.first(:sso_account_id => sso_account_id.to_s)
+    end
+
+    def make_service_available_for_account(service_id, sso_account_id, reason = "test")
+      ServiceEnablement.create(:service_id => service_id.to_i, :sso_account_id => sso_account_id.to_s, :reason => reason)
+    end
+
+    def find_service_account(service_id, sso_account_id)
+      service_object = Service.get(service_id)
+      service_account_object = service_object.service_accounts.first(:sso_account_id => sso_account_id.to_s)
+      service_account_object && {
+        :id             => service_account_object.id,
+        :url            => URL_GEN.partner_service_account(service_object, service_account_object),
+        :messages_url   => URL_GEN.messages(service_object, service_account_object),
+        :invoices_url   => URL_GEN.invoices(service_object, service_account_object),
+        :pushed_service_account => {
+          :provisioned_services_url => service_account_object.provisioned_services_url,
+          :configuration_url => service_account_object.configuration_url,
+          :url => service_account_object.url,
+          :configuration_required => service_account_object.configuration_required,
+        }
+      }
+    end
+
+    def find_provisioned_service(service_account_id, app_deployment_id)
+      service_account = ServiceAccount.get(service_account_id)
+      provisioned_service = service_account.provisioned_services.first(:app_deployment_id => app_deployment_id)
+      provisioned_service && {
+        :id => provisioned_service.id,
+        :url => URL_GEN.partner_provisioned_service(service_account, provisioned_service),
+        :messages_url => URL_GEN.messages(service_account.service, service_account, provisioned_service),
+        :pushed_provisioned_service => {
+          :vars => provisioned_service.vars,
+          :configuration_url => provisioned_service.configuration_url,
+          :configuration_required => provisioned_service.configuration_required,
+          :url => provisioned_service.url
+        }
+      }
+    end
+
+    def latest_invoice
+      invoice = Invoice.last
+      {
+        :total_amount_cents  => invoice.total_amount_cents,
+        :line_item_description => invoice.line_item_description,
+        :service_account_id => invoice.service_account_id,
+      }
+    end
+
+    def latest_status_message
+      if message = Message.last(:message_type => "status")
+        to_return = {
+          :id => message.id,
+          :subject => message.subject,
+          :body => message.body
+        }
+        if message.respond_to?(:service_account) && message.service_account
+          to_return[:service_account_id] = message.service_account.id
+        end
+        if message.respond_to?(:provisioned_service) && message.provisioned_service
+          to_return[:provisioned_service_id] = message.provisioned_service.id
+        end
+        to_return
+      end
+    end
+
+  end
+end

data/fake/lib/ey_services_fake/tresfiestas_fake_rack_app.rb

@@ -0,0 +1,160 @@
+require 'sinatra/base'
+
+module EyServicesFake
+  class TresfiestasFakeRackApp < Sinatra::Base
+    enable :raise_errors
+    disable :dump_errors
+    disable :show_exceptions
+
+    class << self
+      attr_accessor :partner_connection
+      attr_accessor :awsm_connection
+    end
+
+    ################
+    # External API #
+    ################
+
+    get '/api/1/partners/:partner_id/services' do |partner_id|
+      partner = Partner.get!(partner_id)
+      to_return = []
+      partner.services.each do |service|
+        to_return << {"service" => service.attributes.merge('url' => URL_GEN.service(service)) }
+      end
+      to_return.to_json
+    end
+
+    #TODO: auth!
+    post '/api/1/partners/:partner_id/services' do |partner_id|
+      partner = Partner.get!(partner_id)
+      service_json = JSON.parse(request.body.read)["service"]
+      if service_json["name"].to_s.empty?
+        status 400
+        {:error_messages => ["Name can't be blank"]}.to_json
+      else
+        service = Service.create(service_json.merge(:partner_id => partner.id, :revenue_share => 0.3))
+        status 201
+        headers 'Location' => URL_GEN.service(service)
+        {}.to_json
+      end
+    end
+
+    get '/api/1/partners/:partner_id/services/:service_id' do |partner_id, service_id|
+      partner = Partner.get!(partner_id)
+      if service = partner.services.detect{ |s| s.id.to_s == service_id.to_s }
+        {"service" => service.attributes}.to_json
+      else
+        status 404
+        {}.to_json
+      end
+    end
+
+    put '/api/1/partners/:partner_id/services/:service_id' do |partner_id, service_id|
+      partner = Partner.get!(partner_id)
+      service = partner.services.detect{ |s| s.id.to_s == service_id.to_s }
+      update_params = JSON.parse(request.body.read)["service"]
+      if update_params.key?("name") && update_params["name"].to_s.empty?
+        status 400
+        {:error_messages => ["Name can't be blank"]}.to_json
+      else
+        service.update_attributes(update_params)
+        {}.to_json
+      end
+    end
+
+    delete '/api/1/partners/:partner_id/services/:service_id' do |partner_id, service_id|
+      partner = Partner.get!(partner_id)
+      service = partner.services.detect{ |s| s.id.to_s == service_id.to_s }
+      service.destroy
+      {}.to_json
+    end
+
+    put '/api/1/partners/:partner_id/services/:service_id/service_accounts/:service_account_id' do |partner_id, service_id, service_account_id|
+      partner = Partner.get!(partner_id)
+      service = partner.services.detect{ |s| s.id.to_s == service_id.to_s }
+      service_account = service.service_accounts.detect{ |sa| sa.id.to_s == service_account_id.to_s }
+      service_account_atts = JSON.parse(request.body.read)["service_account"]
+      service_account.update_attributes(service_account_atts)
+      {}.to_json
+    end
+
+    put '/api/1/service_accounts/:service_account_id/provisioned_service/:provisioned_service_id' do |service_account_id, provisioned_service_id|
+      service_account = ServiceAccount.get!(service_account_id)
+      provisioned_service = service_account.provisioned_services.detect{ |ps| ps.id.to_s == provisioned_service_id.to_s}
+      atts = JSON.parse(request.body.read)["provisioned_service"]
+      provisioned_service.update_attributes(atts)
+      {}.to_json
+    end
+
+    post '/api/1/partners/:partner_id/services/:service_id/service_accounts/:service_account_id/invoices' do |partner_id, service_id, service_account_id|
+      invoice_params = JSON.parse(request.body.read)["invoice"]
+      unless invoice_params['total_amount_cents'].is_a?(Fixnum)
+        status 400
+        return {:error_messages => ["Total Amount Cents must be an integer"]}.to_json
+      end
+      if invoice_params["line_item_description"].to_s.empty?
+        status 400
+        return {:error_messages => ["Line item description can't be blank"]}.to_json
+      end
+      if invoice_params['total_amount_cents'] < 0
+        status 400
+        return {:error_messages => ["Total amount cents must be greater than or equal to 0"]}.to_json
+      end
+      Invoice.create(invoice_params.merge(:service_account_id => service_account_id.to_i))
+      {}.to_json
+    end
+
+    post '/api/1/partners/:partner_id/services/:service_id/service_accounts/:service_account_id/messages' do |partner_id, service_id, service_account_id|
+      message_params = JSON.parse(request.body.read)["message"]
+      message_type = message_params['message_type']
+      subject = message_params['subject']
+
+      if subject.to_s.empty?
+        status 400
+        return {:error_messages => ["Subject can't be blank."]}.to_json
+      end
+
+      unless ['status', 'notification', 'alert'].include? message_type
+        status 400
+        return {:error_messages => ['Message type must be one of: status, notification or alert']}.to_json
+      end
+
+      service_account = ServiceAccount.get(service_account_id)
+      message = Message.create(message_params.merge(:service_account_id => service_account.id))
+      forward_service_account_message_to_awsm(service_account, message)
+      {}.to_json
+    end
+
+    def forward_service_account_message_to_awsm(service_account, message)
+      #no-op
+    end
+
+    post '/api/1/partners/:partner_id/services/:service_id/service_accounts/:service_account_id/provisioned_service/:provisioned_service_id/messages' do |partner_id, service_id, service_account_id, provisioned_service_id|
+      message_params = JSON.parse(request.body.read)["message"]
+      subject = message_params['subject']
+      message_type = message_params['message_type']
+
+      if subject.to_s.empty?
+        status 400
+        return {:error_messages => ["Subject can't be blank."]}.to_json
+      end
+
+      unless ['status', 'notification', 'alert'].include? message_type
+        status 400
+        return {:error_messages => ['Message type must be one of: status, notification or alert']}.to_json
+      end
+
+      message = Message.create(message_params.merge(:provisioned_service_id => provisioned_service_id.to_i))
+      provisioned_service = ProvisionedService.get(provisioned_service_id)
+      service_account = provisioned_service.service_account
+      message = Message.create(message_params.merge(:provisioned_service_id => provisioned_service.id))
+      forward_provisioned_service_message_to_awsm(provisioned_service, message)
+      {}.to_json
+    end
+
+    def forward_provisioned_service_message_to_awsm(provisioned_service, message)
+      #no-op
+    end
+
+  end
+end

data/fake/lib/ey_services_fake/url_generator.rb

@@ -0,0 +1,37 @@
+module EyServicesFake
+  class UrlGenerator
+
+    def initialize(base_url)
+      @base_url = base_url
+    end
+
+    def service_registration(partner)
+      "#{@base_url}/api/1/partners/#{partner.id}/services"
+    end
+
+    def service(service)
+      "#{@base_url}/api/1/partners/#{service.partner_id}/services/#{service.id}"
+    end
+
+    def partner_service_account(service, service_account)
+      "#{@base_url}/api/1/partners/#{service.partner_id}/services/#{service.id}/service_accounts/#{service_account.id}"
+    end
+
+    def messages(service, service_account, provisioned_service = nil)
+      if provisioned_service
+        "#{@base_url}/api/1/partners/#{service.partner_id}/services/#{service.id}/service_accounts/#{service_account.id}/provisioned_service/#{provisioned_service.id}/messages"
+      else
+        "#{@base_url}/api/1/partners/#{service.partner_id}/services/#{service.id}/service_accounts/#{service_account.id}/messages"
+      end
+    end
+
+    def invoices(service, service_account)
+      "#{@base_url}/api/1/partners/#{service.partner_id}/services/#{service.id}/service_accounts/#{service_account.id}/invoices"
+    end
+
+    def partner_provisioned_service(service_account, provisioned_service)
+      "#{@base_url}/api/1/service_accounts/#{service_account.id}/provisioned_service/#{provisioned_service.id}"
+    end
+
+  end
+end

data/fake/lib/ey_services_fake/version.rb

@@ -0,0 +1,3 @@
+module EyServicesFake
+  VERSION = "0.3.4"
+end

data/lib/ey_services_api/version.rb

@@ -1,5 +1,5 @@
 module EY
   module ServicesAPI
-    VERSION = "0.3.3"
+    VERSION = "0.3.4"
   end
 end

data/script/ci

@@ -8,9 +8,6 @@ case "$1" in
 "internal")
    echo "running internal tests"
    export BUNDLE_GEMFILE=EYIntegratedGemfile
-   export LANG="en_US.utf-8"
-   source use_ruby.sh
-   use_ruby 1.9.2
    ;;
 "public")
    echo "running public tests"

metadata

@@ -1,78 +1,59 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: ey_services_api
-version: !ruby/object:Gem::Version 
-  hash: 21
+version: !ruby/object:Gem::Version
+  version: 0.3.4
   prerelease: 
-  segments: 
-  - 0
-  - 3
-  - 3
-  version: 0.3.3
 platform: ruby
-authors: 
+authors:
 - Jacob & Thorben & David & mkb & Josh & Others
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-03-02 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70182942688180 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: json
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70182942688180
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70182942686540 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: ey_api_hmac
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *70182942686540
+- !ruby/object:Gem::Dependency
+  name: ey_api_hmac
+  requirement: &70182942685240 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 19
-        segments: 
-        - 0
-        - 3
-        - 0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.3.0
   type: :runtime
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: *70182942685240
 description: API for Partner Services (talks to services.engineyard.com)
-email: 
+email:
 - jacob@engineyard.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .rspec
+- .rvmrc
 - CHANGELOG
 - EYIntegratedGemfile
 - Gemfile
@@ -81,6 +62,15 @@ files:
 - Rakefile
 - ci.yml
 - ey_services_api.gemspec
+- fake/ey_services_fake.gemspec
+- fake/lib/ey_services_fake/mock_backend.rb
+- fake/lib/ey_services_fake/mocking_bird_service.rb
+- fake/lib/ey_services_fake/models.rb
+- fake/lib/ey_services_fake/reacharound_awsm.rb
+- fake/lib/ey_services_fake/tresfiestas_fake.rb
+- fake/lib/ey_services_fake/tresfiestas_fake_rack_app.rb
+- fake/lib/ey_services_fake/url_generator.rb
+- fake/lib/ey_services_fake/version.rb
 - lib/ey_services_api.rb
 - lib/ey_services_api/api_struct.rb
 - lib/ey_services_api/connection.rb
@@ -100,40 +90,31 @@ files:
 - spec/service_account_creation_spec.rb
 - spec/service_spec.rb
 - spec/spec_helper.rb
-homepage: ""
+homepage: ''
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: ey_services_api
-rubygems_version: 1.8.10
+rubygems_version: 1.8.12
 signing_key: 
 specification_version: 3
 summary: API for Partner Services (talks to services.engineyard.com)
-test_files: 
+test_files:
 - spec/invoice_spec.rb
 - spec/message_spec.rb
 - spec/provisioned_service_creation_spec.rb