ey_services_api 0.3.7 → 0.3.8

data/ey_services_api.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "ey_services_api"
 
-  s.files         = `git ls-files`.split("\n")
+  s.files         = (`git ls-files`.split("\n") - `git ls-files -- fake`.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"]

data/lib/ey_services_api/version.rb

@@ -1,5 +1,5 @@
 module EY
   module ServicesAPI
-    VERSION = "0.3.7"
+    VERSION = "0.3.8"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ey_services_api
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 3
   prerelease: 
   segments: 
   - 0
   - 3
-  - 7
-  version: 0.3.7
+  - 8
+  version: 0.3.8
 platform: ruby
 authors: 
 - Jacob & Thorben & David & mkb & Josh & Others
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-16 00:00:00 Z
+date: 2012-04-04 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -82,15 +82,6 @@ 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
@@ -139,7 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: ey_services_api
-rubygems_version: 1.8.10
+rubygems_version: 1.8.19
 signing_key: 
 specification_version: 3
 summary: API for Partner Services (talks to services.engineyard.com)

data/fake/ey_services_fake.gemspec

@@ -1,24 +0,0 @@
-# -*- 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    = "https://github.com/engineyard/ey_services_api"
-  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"
-  s.add_dependency "request_visualizer"
-end

data/fake/lib/ey_services_fake/mock_backend.rb

@@ -1,210 +0,0 @@
-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 app_for(actor_name)
-      this = self
-      @apps ||= {}
-      @apps[actor_name] ||= Rack::Builder.new do
-        this.actors.each do |k, actor|
-          if actor.respond_to?(:extra_middlewares)
-            self.instance_eval(&actor.extra_middlewares)
-          end
-        end
-        if ENV["REQUEST_DEBUG"]
-          require 'request_visualizer'
-          use RequestVisualizer do |str|
-            found = str
-            this.actors.each do |k, actor|
-              if str.match(actor.base_url)
-                found = k.to_s
-              end
-            end
-            found
-          end
-        end
-        run this.actors[actor_name].app
-      end
-    end
-
-    def app
-      this = self
-      @app ||= Rack::Builder.new do
-        this.actors.each do |k, actor|
-          map "#{actor.base_url}/" do
-            run this.app_for(k)
-          end
-        end
-      end
-    end
-
-    attr_reader :actors
-    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, app_for(:awsm))
-        actor(:awsm).setup(awsm_hash[:auth_id], awsm_hash[:auth_key], actor(:tresfiestas).base_url, app_for(:tresfiestas))
-      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, app_for(:service_provider))
-        @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, app_for(:service_provider))
-          end
-        end
-        actor(:service_provider).setup(partner_hash[:auth_id], partner_hash[:auth_key], actor(:tresfiestas).base_url, app_for(:tresfiestas))
-      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
-
-    def service_account_sso_url
-      configuration_url = service_account[:pushed_service_account][:configuration_url]
-      params = {
-        'timestamp' => Time.now.iso8601,
-        'ey_user_id' => sso_user.id,
-        'ey_user_name' => "Person Name",
-        'ey_return_to_url' => "https://cloud.engineyard.com/dashboard",
-        'access_level' => 'owner',
-      }
-      EY::ApiHMAC::SSO.sign(configuration_url,
-                            params,
-                            partner[:auth_id],
-                            partner[:auth_key])
-    end
-
-  end
-end

data/fake/lib/ey_services_fake/mocking_bird_service.rb

@@ -1,155 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,166 +0,0 @@
-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
-
-      get '/dashboard' do
-        "Hello this is fake AWSM dashboard"
-      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

@@ -1,137 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

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