miasma 0.2.22 → 0.2.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c819001bad6e06682bf9a373462a1acf4cf317cb
-  data.tar.gz: 0d477fdeaba9b395fceea08c51e5230aff885528
+  metadata.gz: 9ad1bada860e09a472096990620ec270dbb3e61c
+  data.tar.gz: 4ff7b4e6f102527bada9c77eff33b04bf3926ebc
 SHA512:
-  metadata.gz: 34e65fa95bfd5f6ad77a4f587dbe006fe38b6cad19bb62541f156b9559f760be6bba9cd442220686925b9dda29d8c4a9003d7c91dfc79d42474968ee617efa41
-  data.tar.gz: d9f32e1b81c4bc143dd043542be3a66b7dc4957abc8dd18a6bb022be892839e904b84028662c91b1562722e5ba63b82dbe5bffd40c6543e0d44e4c02d3162bae
+  metadata.gz: b6d497bf68b667171a443bfab973856aa2fc9b87a48f13e8ab8ae9b26ca43e414f8aa07b5297e86a2060a96a381cba4a17ab398d61ac3e1de0caaced53bc3ea0
+  data.tar.gz: d90757a5e25193d975313e72226a0266e210aa615e20dc867a02b44c8d7c7e895bc6a25834f4898487b4e363f4908de7457d508388a5d9312640c14d59b43d3a

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# v0.2.24
+* Add support for `http_proxy`, `https_proxy`, and `no_proxy` (#11)
+* Use common helper modules for bogo library (#10)
+
 # v0.2.22
 * Fix lazy attribute loading on subclasses
 

data/lib/miasma.rb

@@ -1,5 +1,7 @@
 # Load in dependencies
 require 'http'
+require 'bogo'
+require 'bogo/http_proxy'
 require 'multi_json'
 require 'multi_xml'
 

data/lib/miasma/utils/animal_strings.rb

@@ -4,25 +4,7 @@ module Miasma
 
   module Utils
     # Animal stylings on strings
-    module AnimalStrings
-
-      # Camel case string
-      # @param string [String]
-      # @return [String]
-      def camel(string)
-        string.to_s.split('_').map{|k| "#{k.slice(0,1).upcase}#{k.slice(1,k.length)}"}.join
-      end
-
-      # Snake case (underscore) string
-      #
-      # @param string [String]
-      # @return [String]
-      def snake(string)
-        string.to_s.gsub(/([a-z])([A-Z])/, '\1_\2').gsub('-', '_').downcase
-      end
-
-    end
-
+    AnimalStrings = Bogo::AnimalStrings
     extend AnimalStrings
   end
 

data/lib/miasma/utils/lazy.rb

@@ -4,233 +4,6 @@ require 'digest/sha2'
 module Miasma
   module Utils
     # Adds functionality to facilitate laziness
-    module Lazy
-
-      # Instance methods for laziness
-      module InstanceMethods
-
-        # @return [Smash] argument hash
-        def data
-          unless(@data)
-            @data = Smash.new
-          end
-          @data
-        end
-
-        # @return [Smash] updated data
-        def dirty
-          unless(@dirty)
-            @dirty = Smash.new
-          end
-          @dirty
-        end
-
-        # @return [Smash] current data state
-        def attributes
-          data.merge(dirty)
-        end
-
-        # Create new instance
-        #
-        # @param args [Hash]
-        # @return [self]
-        def load_data(args={})
-          args = args.to_smash
-          @data = Smash.new
-          self.class.attributes.each do |name, options|
-            val = args[name]
-            if(options[:required] && !args.has_key?(name) && !options.has_key?(:default))
-              raise ArgumentError.new("Missing required option: `#{name}`")
-            end
-            if(val.nil? && !args.has_key?(name) && options[:default])
-              if(options[:default])
-                val = options[:default].respond_to?(:call) ? options[:default].call : options[:default]
-              end
-            end
-            if(args.has_key?(name) || val)
-              self.send("#{name}=", val)
-            end
-          end
-          self
-        end
-
-        # Identifies valid state and automatically
-        # merges dirty attributes into data, clears
-        # dirty attributes
-        #
-        # @return [self]
-        def valid_state
-          data.merge!(dirty)
-          dirty.clear
-          @_checksum = Digest::SHA256.hexdigest(MultiJson.dump(data))
-          self
-        end
-
-        # Model is dirty or specific attribute is dirty
-        #
-        # @param attr [String, Symbol] name of attribute
-        # @return [TrueClass, FalseClass] model or attribute is dirty
-        def dirty?(attr=nil)
-          if(attr)
-            dirty.has_key?(attr)
-          else
-            if(@_checksum)
-              !dirty.empty? ||
-                @_checksum != Digest::SHA256.hexdigest(MultiJson.dump(data))
-            else
-              true
-            end
-          end
-        end
-
-        # @return [String]
-        def to_s
-          "<#{self.class.name}:#{object_id}>"
-        end
-
-        # @return [String]
-        def inspect
-          "<#{self.class.name}:#{object_id} [#{data.inspect}]>"
-        end
-
-      end
-
-      # Class methods for laziness
-      module ClassMethods
-
-        # Add new attributes to class
-        #
-        # @param name [String]
-        # @param type [Class, Array<Class>]
-        # @param options [Hash]
-        # @option options [TrueClass, FalseClass] :required must be provided on initialization
-        # @option options [Object, Proc] :default default value
-        # @option options [Proc] :coerce
-        # @return [nil]
-        def attribute(name, type, options={})
-          name = name.to_sym
-          options = options.to_smash
-          attributes[name] = Smash.new(:type => type).merge(options)
-          coerce = attributes[name][:coerce]
-          valid_types = [attributes[name][:type], NilClass].flatten.compact
-          allowed_values = attributes[name][:allowed]
-          multiple_values = attributes[name][:multiple]
-          depends_on = attributes[name][:depends]
-          define_method(name) do
-            send(depends_on) if depends_on
-            self.class.on_missing(self) unless data.has_key?(name) || dirty.has_key?(name)
-            dirty[name] || data[name] || self.class.attributes[name][:default]
-          end
-          define_method("#{name}=") do |val|
-            values = multiple_values && val.is_a?(Array) ? val : [val]
-            values.map! do |item|
-              valid_type = valid_types.detect do |klass|
-                item.is_a?(klass)
-              end
-              if(coerce && !valid_type)
-                item = coerce.arity == 2 ? coerce.call(item, self) : coerce.call(item)
-              end
-              valid_type = valid_types.detect do |klass|
-                item.is_a?(klass)
-              end
-              unless(valid_type)
-                raise TypeError.new("Invalid type for `#{name}` (#{item} <#{item.class}>). Valid - #{valid_types.map(&:to_s).join(',')}")
-              end
-              if(allowed_values)
-                unless(allowed_values.include?(item))
-                  raise ArgumentError.new("Invalid value provided for `#{name}` (#{item.inspect}). Allowed - #{allowed_values.map(&:inspect).join(', ')}")
-                end
-              end
-              item
-            end
-            if(!multiple_values && !val.is_a?(Array))
-              dirty[name] = values.first
-            else
-              dirty[name] = values
-            end
-          end
-          define_method("#{name}?") do
-            send(depends_on) if depends_on
-            self.class.on_missing(self) unless data.has_key?(name)
-            !!data[name]
-          end
-          nil
-        end
-
-        # Return attributes
-        #
-        # @param args [Symbol] :required or :optional
-        # @return [Array<Hash>]
-        def attributes(*args)
-          @attributes ||= Smash.new
-          if(args.include?(:required))
-            Smash[@attributes.find_all{|k,v| v[:required]}]
-          elsif(args.include?(:optional))
-            Smash[@attributes.find_all{|k,v| !v[:required]}]
-          else
-            @attributes
-          end
-        end
-
-        # Instance method to call on missing attribute or
-        # object to call method on if set
-        #
-        # @param param [Symbol, Object]
-        # @return [Symbol]
-        def on_missing(param=nil)
-          if(param)
-            if(param.is_a?(Symbol))
-              @missing_method = param
-            else
-              if(@missing_method && !@calling_on_missing)
-                @calling_on_missing = true
-                begin
-                  param.send(@missing_method)
-                ensure
-                  @calling_on_missing = false
-                end
-              end
-              @missing_method
-            end
-          else
-            @missing_method
-          end
-        end
-
-        # Directly set attribute hash
-        #
-        # @param attrs [Hash]
-        # @return [TrueClass]
-        # @todo need deep dup here
-        def set_attributes(attrs)
-          @attributes = attrs.to_smash
-          true
-        end
-
-      end
-
-      class << self
-
-        # Injects laziness into class
-        #
-        # @param klass [Class]
-        def included(klass)
-          klass.class_eval do
-            include InstanceMethods
-            extend ClassMethods
-
-            class << self
-
-              def inherited(klass)
-                klass.set_attributes(self.attributes.to_smash)
-              end
-
-            end
-          end
-        end
-
-      end
-
-    end
+    Lazy = Bogo::Lazy
   end
 end

data/lib/miasma/utils/memoization.rb

@@ -3,53 +3,6 @@ require 'miasma'
 module Miasma
   module Utils
     # Memoization helpers
-    module Memoization
-
-      # Memoize data
-      #
-      # @param key [String, Symbol] identifier for data
-      # @param direct [Truthy, Falsey] direct skips key prepend of object id
-      # @yield block to create data
-      # @yieldreturn data to memoize
-      # @return [Object] data
-      def memoize(key, direct=false)
-        unless(direct)
-          key = "#{self.object_id}_#{key}"
-        end
-        unless(_memo.has_key?(key))
-          _memo[key] = yield
-        end
-        _memo[key]
-      end
-
-      def _memo
-        Thread.current[:miasma_memoization] ||= Smash.new
-      end
-
-      # Remove memoized value
-      #
-      # @param key [String, Symbol] identifier for data
-      # @param direct [Truthy, Falsey] direct skips key prepend of object id
-      # @return [NilClass]
-      def unmemoize(key, direct=false)
-        unless(direct)
-          key = "#{self.object_id}_#{key}"
-        end
-        _memo.delete(key)
-      end
-
-      # Remove all memoized values
-      #
-      # @return [TrueClass]
-      def clear_memoizations!
-        _memo.keys.find_all do |key|
-          key.to_s.start_with?("#{self.object_id}_")
-        end.each do |key|
-          _memo.delete(key)
-        end
-        true
-      end
-
-    end
+    Memoization = Bogo::Memoization
   end
 end

data/lib/miasma/utils/smash.rb

@@ -1,154 +1,8 @@
-require 'hashie'
-require 'digest/sha2'
 require 'miasma'
 
 module Miasma
   module Utils
-
     # Customized Hash
-    class Smash < Hash
-      include Hashie::Extensions::IndifferentAccess
-      include Hashie::Extensions::MergeInitializer
-      include Hashie::Extensions::DeepMerge
-      include Hashie::Extensions::Coercion
-
-      coerce_value Hash, Smash
-
-      # Create new instance
-      #
-      # @param args [Object] argument list
-      def initialize(*args)
-        base = nil
-        if(args.first.is_a?(::Hash))
-          base = args.shift
-        end
-        super *args
-        if(base)
-          self.replace(base.to_smash)
-        end
-      end
-
-      def merge!(hash)
-        hash = hash.to_smash
-        super(hash)
-      end
-
-      # Get value at given path
-      #
-      # @param args [String, Symbol] key path to walk
-      # @return [Object, NilClass]
-      def retrieve(*args)
-        args.inject(self) do |memo, key|
-          if(memo.is_a?(Hash))
-            memo.to_smash[key]
-          else
-            nil
-          end
-        end
-      end
-      alias_method :get, :retrieve
-
-      # Fetch value at given path or return a default value
-      #
-      # @param args [String, Symbol, Object] key path to walk. last value default to return
-      # @return [Object] value at key or default value
-      def fetch(*args)
-        default_value = args.pop
-        retrieve(*args) || default_value
-      end
-
-      # Set value at given path
-      #
-      # @param args [String, Symbol, Object] key path to walk. set last value to given path
-      # @return [Object] value set
-      def set(*args)
-        unless(args.size > 1)
-          raise ArgumentError.new 'Set requires at least one key and a value'
-        end
-        value = args.pop
-        set_key = args.pop
-        leaf = args.inject(self) do |memo, key|
-          unless(memo[key].is_a?(Hash))
-            memo[key] = Smash.new
-          end
-          memo[key]
-        end
-        leaf[set_key] = value
-        value
-      end
-
-      # Convert to Hash
-      #
-      # @return [Hash]
-      def to_hash(*args)
-        self.to_type_converter(::Hash, :to_hash, *args)
-      end
-
-      # Calculate checksum of hash (sha256)
-      #
-      # @return [String] checksum
-      def checksum
-        Digest::SHA256.hexdigest(self.to_smash(:sorted).to_s)
-      end
-
-    end
+    Smash = Bogo::Smash
   end
-
-end
-
-# Hook helper into toplevel `Hash`
-class Hash
-
-  # Convert to Smash
-  #
-  # @return [Smash]
-  def to_smash(*args)
-    self.to_type_converter(::Smash, :to_smash, *args)
-  end
-  alias_method :hulk_smash, :to_smash
-
-  protected
-
-  # Convert to type
-  #
-  # @param type [Class] hash type
-  # @param convert_call [Symbol] builtin hash convert
-  # @return [Smash]
-  def to_type_converter(type, convert_call, *args)
-    type.new.tap do |smash|
-      if(args.include?(:sorted))
-        process = self.sort_by do |entry|
-          entry.first.to_s
-        end
-      else
-        process = self
-      end
-      process.each do |k,v|
-        smash[k.is_a?(Symbol) ? k.to_s : k] = smash_conversion(v, convert_call, *args)
-      end
-    end
-  end
-
-  # Convert object to smash if applicable
-  #
-  # @param obj [Object]
-  # @param convert_call [Symbol] builtin hash convert
-  # @return [Smash, Object]
-  def smash_conversion(obj, convert_call, *args)
-    case obj
-    when Hash
-      obj.send(convert_call, *args)
-    when Array
-      obj.map do |i|
-        smash_conversion(i, convert_call, *args)
-      end
-    else
-      obj
-    end
-  end
-
-end
-
-unless(defined?(Smash))
-  Smash = Miasma::Utils::Smash
 end

data/lib/miasma/version.rb

@@ -1,4 +1,4 @@
 module Miasma
   # current library version
-  VERSION = Gem::Version.new('0.2.22')
+  VERSION = Gem::Version.new('0.2.24')
 end

data/miasma.gemspec

@@ -10,11 +10,11 @@ Gem::Specification.new do |s|
   s.description = 'Smoggy API'
   s.license = 'Apache 2.0'
   s.require_path = 'lib'
-  s.add_runtime_dependency 'hashie'
   s.add_runtime_dependency 'http'
   s.add_runtime_dependency 'multi_json'
   s.add_runtime_dependency 'multi_xml'
   s.add_runtime_dependency 'xml-simple'
+  s.add_runtime_dependency 'bogo', '>= 0.1.20', '< 1.0'
   # Include provider libs that do not have outside deps
   s.add_runtime_dependency 'miasma-aws'
   s.add_runtime_dependency 'miasma-open-stack'
@@ -25,5 +25,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'minitest'
   s.add_development_dependency 'vcr'
   s.add_development_dependency 'webmock'
-  s.files = Dir['{bin,lib,test}/**/*'] + %w(miasma.gemspec README.md CHANGELOG.md LICENSE)
+  s.files = Dir['{bin,lib}/**/*'] + %w(miasma.gemspec README.md CHANGELOG.md LICENSE)
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: miasma
 version: !ruby/object:Gem::Version
-  version: 0.2.22
+  version: 0.2.24
 platform: ruby
 authors:
 - Chris Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-23 00:00:00.000000000 Z
+date: 2015-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: hashie
+  name: http
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: http
+  name: multi_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: multi_json
+  name: multi_xml
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: multi_xml
+  name: xml-simple
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,19 +67,25 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: xml-simple
+  name: bogo
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.20
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.20
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: miasma-aws
   requirement: !ruby/object:Gem::Requirement
@@ -231,15 +237,6 @@ files:
 - lib/miasma/utils/smash.rb
 - lib/miasma/version.rb
 - miasma.gemspec
-- test/spec.rb
-- test/specs/miasma_spec.rb
-- test/specs/models/compute_abstract.rb
-- test/specs/models/load_balancer_abstract.rb
-- test/specs/models/orchestration_abstract.rb
-- test/specs/models/storage_abstract.rb
-- test/specs/utils/animal_strings_spec.rb
-- test/specs/utils/memoization_spec.rb
-- test/specs/utils/smash_spec.rb
 homepage: https://github.com/miasma-rb/miasma
 licenses:
 - Apache 2.0

data/test/spec.rb

@@ -1,20 +0,0 @@
-require 'vcr'
-require 'webmock/minitest'
-require 'minitest/autorun'
-
-require 'miasma'
-
-spec_dir = File.join(File.dirname(__FILE__), 'specs')
-
-Dir.glob(File.join(spec_dir, 'models', '*.rb')).each do |path|
-  require File.expand_path(path)
-end
-
-Dir.glob(File.join(spec_dir, '**/**/*_spec.rb')).each do |path|
-  require File.expand_path(path)
-end
-
-VCR.configure do |c|
-  c.cassette_library_dir = File.join(spec_dir, 'cassettes')
-  c.hook_into :webmock
-end

data/test/specs/miasma_spec.rb

@@ -1,33 +0,0 @@
-describe Miasma do
-  it 'should provide an #api entry method' do
-    Miasma.respond_to?(:api).must_equal true
-  end
-
-  describe 'Miasma.api' do
-
-    it 'should require `:type` argument' do
-      lambda do
-        Miasma.api(:provider => '', :credentials => {})
-      end.must_raise ArgumentError
-    end
-
-    it 'should require `:provider` argument' do
-      lambda do
-        Miasma.api(:type => '', :credentials => {})
-      end.must_raise ArgumentError
-    end
-
-    it 'should require `:credentials` argument' do
-      lambda do
-        Miasma.api(:provider => '', :type => '')
-      end.must_raise ArgumentError
-    end
-
-    it 'should fail to load unknown provider' do
-      lambda do
-        Miasma.api(:provider => :unknown, :type => :compute, :credentials => {})
-      end.must_raise Miasma::Error
-    end
-
-  end
-end

data/test/specs/models/compute_abstract.rb

@@ -1,118 +0,0 @@
-MIASMA_COMPUTE_ABSTRACT = ->{
-
-  # Required `let`s:
-  # * compute: compute API
-  # * build_args: server build arguments [Smash]
-  # * cassette_prefix: cassette file prefix [String]
-
-  describe Miasma::Models::Compute do
-
-    it 'should provide #servers collection' do
-      compute.servers.must_be_kind_of Miasma::Models::Compute::Servers
-    end
-
-    describe Miasma::Models::Compute::Servers do
-
-      it 'should provide instance class used within collection' do
-        compute.servers.model.must_equal Miasma::Models::Compute::Server
-      end
-
-      it 'should build new instance for collection' do
-        instance = compute.servers.build(:name => 'test')
-        instance.must_be_kind_of Miasma::Models::Compute::Server
-      end
-
-      it 'should provide #all servers' do
-        VCR.use_cassette("#{cassette_prefix}_servers_all") do
-          compute.servers.all.must_be_kind_of Array
-        end
-      end
-
-    end
-
-    describe Miasma::Models::Compute::Server do
-
-      before do
-        @instance = compute.servers.build(build_args)
-        VCR.use_cassette("#{cassette_prefix}_server_before_create") do |obj|
-          @instance.save
-          until(@instance.state == :running)
-            sleep(obj.recording? ? 60 : 0.01)
-            @instance.reload
-          end
-        end
-      end
-
-      after do
-        VCR.use_cassette("#{cassette_prefix}_server_after_destroy") do
-          @instance.destroy
-        end
-      end
-
-      let(:instance){ @instance }
-
-      describe 'instance methods' do
-
-        it 'should have a name' do
-          instance.name.must_equal build_args[:name]
-        end
-
-        it 'should have an image_id' do
-          instance.image_id.must_equal build_args[:image_id]
-        end
-
-        it 'should have a flavor_id' do
-          instance.flavor_id.must_equal build_args[:flavor_id]
-        end
-
-        it 'should have an address' do
-          instance.addresses.detect do |addr|
-            addr.version == 4
-          end.address.must_match /^(\d+)+\.(\d+)\.(\d+)\.(\d+)$/
-        end
-
-        it 'should have a status' do
-          instance.status.wont_be_nil
-        end
-
-        it 'should be in :running state' do
-          instance.state.must_equal :running
-        end
-
-      end
-
-    end
-
-    describe 'instance lifecycle' do
-      it 'should create new server, reload details and destroy server' do
-        VCR.use_cassette("#{cassette_prefix}_servers_create") do |obj|
-          instance = compute.servers.build(build_args)
-          instance.save
-          instance.id.wont_be_nil
-          instance.state.must_equal :pending
-          compute.servers.reload.get(instance.id).wont_be_nil
-          until(instance.state == :running)
-            sleep(obj.recording? ? 60 : 0.01)
-            instance.reload
-          end
-          instance.state.must_equal :running
-          instance.destroy
-          while(instance.state == :running)
-            sleep(obj.recording? ? 10 : 0.01)
-            instance.reload
-          end
-          [:pending, :terminated].must_include instance.state
-          if(instance.state == :pending)
-            until(instance.state == :terminated)
-              sleep(obj.recording? ? 60 : 0.01)
-              instance.reload
-            end
-            instance.state.must_equal :terminated
-          end
-        end
-      end
-
-    end
-
-  end
-}

data/test/specs/models/load_balancer_abstract.rb

@@ -1,88 +0,0 @@
-MIASMA_LOAD_BALANCER_ABSTRACT = ->{
-
-  # Required `let`s:
-  # * load_balancer: load balancer API
-  # * build_args: load balancer build arguments [Smash]
-  # * cassette_prefix: cassette file prefix [String]
-
-  describe Miasma::Models::LoadBalancer do
-
-    it 'should provide #balancers collection' do
-      load_balancer.balancers.must_be_kind_of Miasma::Models::LoadBalancer::Balancers
-    end
-
-    describe Miasma::Models::LoadBalancer::Balancers do
-
-      it 'should provide instance class used within collection' do
-        load_balancer.balancers.model.must_equal Miasma::Models::LoadBalancer::Balancer
-      end
-
-      it 'should build new instance for collection' do
-        instance = load_balancer.balancers.build
-        instance.must_be_kind_of Miasma::Models::LoadBalancer::Balancer
-      end
-
-      it 'should provide #all balancers' do
-        VCR.use_cassette("#{cassette_prefix}_balancers_all") do
-          load_balancer.balancers.all.must_be_kind_of Array
-        end
-      end
-
-    end
-
-    describe Miasma::Models::LoadBalancer::Balancer do
-
-      before do
-        @balancer = load_balancer.balancers.build(build_args)
-        VCR.use_cassette("#{cassette_prefix}_balancer_before_create") do |obj|
-          @balancer.save
-          until(@balancer.state == :active)
-            sleep(obj.recording? ? 60 : 0.01)
-            @balancer.reload
-          end
-        end
-      end
-
-      after do
-        VCR.use_cassette("#{cassette_prefix}_balancer_after_destroy") do
-          @balancer.destroy
-        end
-      end
-
-      let(:balancer){ @balancer }
-
-      describe 'collection' do
-
-        it 'should include balancer' do
-          VCR.use_cassette("#{cassette_prefix}_balancer_direct_fetch") do
-            load_balancer.balancers.reload.get(balancer.id).wont_be_nil
-          end
-        end
-
-      end
-
-      describe 'balancer methods' do
-
-        it 'should have a name' do
-          balancer.name.must_equal build_args[:name]
-        end
-
-        it 'should be in :active state' do
-          balancer.state.must_equal :active
-        end
-
-        it 'should have a status' do
-          balancer.status.wont_be_nil
-          balancer.status.must_be_kind_of String
-        end
-
-        it 'should have a public address' do
-          balancer.public_addresses.wont_be :empty?
-        end
-
-      end
-
-    end
-
-  end
-}

data/test/specs/models/orchestration_abstract.rb

@@ -1,123 +0,0 @@
-MIASMA_ORCHESTRATION_ABSTRACT = ->{
-
-  # Required `let`s:
-  # * orchestration: orchestration API
-  # * build_args: stack build arguments [Smash]
-  # * cassette_prefix: cassette file prefix [String]
-
-  describe Miasma::Models::Orchestration do
-
-    it 'should provide #stacks collection' do
-      orchestration.stacks.must_be_kind_of Miasma::Models::Orchestration::Stacks
-    end
-
-    describe Miasma::Models::Orchestration::Stacks do
-
-      it 'should provide instance class used within collection' do
-        orchestration.stacks.model.must_equal Miasma::Models::Orchestration::Stack
-      end
-
-      it 'should build new instance for collection' do
-        instance = orchestration.stacks.build
-        instance.must_be_kind_of Miasma::Models::Orchestration::Stack
-      end
-
-      it 'should provide #all stacks' do
-        VCR.use_cassette("#{cassette_prefix}_stacks_all") do
-          orchestration.stacks.all.must_be_kind_of Array
-        end
-      end
-
-    end
-
-    describe Miasma::Models::Orchestration::Stacks do
-
-      before do
-        @stack = orchestration.stacks.build(build_args)
-        VCR.use_cassette("#{cassette_prefix}_stacks_before_create") do |obj|
-          @stack.save
-          until(@stack.state == :create_complete)
-            sleep(obj.recording? ? 60 : 0.01)
-            @stack.reload
-          end
-          @stack.template
-          orchestration.stacks.reload
-        end
-      end
-
-      after do
-        VCR.use_cassette("#{cassette_prefix}_stacks_after_destroy") do
-          @stack.destroy
-        end
-      end
-
-      let(:stack){ @stack }
-
-      describe 'collection' do
-
-        it 'should include stack' do
-          VCR.use_cassette("#{cassette_prefix}_stacks_direct_fetch") do
-            orchestration.stacks.all.detect{|s| s.id == stack.id}.wont_be_nil
-            orchestration.stacks.get(stack.id).wont_be_nil
-          end
-        end
-
-      end
-
-      describe 'instance methods' do
-
-        it 'should have a name' do
-          stack.name.must_equal build_args[:name]
-        end
-
-        it 'should be in :create_complete state' do
-          stack.state.must_equal :create_complete
-        end
-
-        it 'should have a status' do
-          stack.status.must_be_kind_of String
-        end
-
-        it 'should have a creation time' do
-          stack.created.must_be_kind_of Time
-        end
-
-        it 'should have parameters used for creation' do
-          stack.parameters.to_smash.must_equal build_args[:parameters].to_smash
-        end
-
-        it 'should include the templated used for creation' do
-          stack.template.to_smash.must_equal build_args[:template].to_smash
-        end
-
-      end
-
-    end
-
-    describe 'instance lifecycle' do
-      it 'should create new stack, reload details and destroy stack' do
-        VCR.use_cassette("#{cassette_prefix}_stack_create") do |obj|
-          stack = orchestration.stacks.build(build_args.merge(:name => 'miasma-test-stack-2'))
-          stack.save
-          stack.id.wont_be_nil
-          stack.state.must_equal :create_in_progress
-          orchestration.stacks.reload.get(stack.id).wont_be_nil
-          until(stack.state == :create_complete)
-            sleep(obj.recording? ? 60 : 0.01)
-            stack.reload
-          end
-          stack.state.must_equal :create_complete
-          stack.destroy
-          [:delete_in_progress, :delete_complete].must_include stack.state
-          until(stack.state == :delete_complete)
-            sleep(obj.recording? ? 60 : 0.01)
-            stack.reload
-          end
-          stack.state.must_equal :delete_complete
-        end
-      end
-
-    end
-
-  end
-}

data/test/specs/models/storage_abstract.rb

@@ -1,120 +0,0 @@
-require 'open-uri'
-
-MIASMA_STORAGE_ABSTRACT = ->{
-
-  # Required `let`s:
-  # * storage: storage API
-  # * cassette_prefix: cassette file prefix [String]
-
-  describe Miasma::Models::Storage do
-
-    it 'should provide #buckets collection' do
-      storage.buckets.must_be_kind_of Miasma::Models::Storage::Buckets
-    end
-
-    describe Miasma::Models::Storage::Buckets do
-
-      it 'should provide instance class used within collection' do
-        storage.buckets.model.must_equal Miasma::Models::Storage::Bucket
-      end
-
-      it 'should build new instance for collection' do
-        storage.buckets.build.must_be_kind_of Miasma::Models::Storage::Bucket
-      end
-
-      it 'should provide #all buckets' do
-        VCR.use_cassette("#{cassette_prefix}_buckets_all") do
-          storage.buckets.all.must_be_kind_of Array
-        end
-      end
-
-    end
-
-    describe Miasma::Models::Storage::Bucket do
-
-      it 'should act like a bucket' do
-        bucket = storage.buckets.build(:name => 'miasma-test-bucket-010')
-        VCR.use_cassette("#{cassette_prefix}_storage_bucket") do |obj|
-          bucket.save
-          bucket.reload
-
-          # should include the bucket
-          storage.buckets.reload.get('miasma-test-bucket-010').wont_be_nil
-          # should have a name
-          bucket.name.must_equal 'miasma-test-bucket-010'
-          # should have a #files collection
-          bucket.files.must_be_kind_of Miasma::Models::Storage::Files
-          #should provide #all files
-          bucket.files.all.must_be_kind_of Array
-          # should include reference to containing bucket
-          bucket.files.bucket.must_equal bucket
-          # should build new instance for collection
-          bucket.files.build.must_be_kind_of Miasma::Models::Storage::File
-
-          file_content = 'blahblahblah'
-          file = bucket.files.build
-          file.name = 'miasma-test-file'
-          file.body = file_content
-          file.save
-          file.reload
-
-          # should have a name
-          file.name.must_equal 'miasma-test-file'
-          # should have a size
-          file.size.must_equal file_content.size
-          # should have an updated timestamp
-          file.updated.must_be_kind_of Time
-          # should create a valid url
-          open(file.url).read.must_equal file_content
-          # should have a body
-          file.body.must_respond_to :readpartial
-          file.body.readpartial(Miasma::Models::Storage::READ_BODY_CHUNK_SIZE).must_equal file_content
-          file.destroy
-
-          big_file_content = '*' * Miasma::Models::Storage::MAX_BODY_SIZE_FOR_STRINGIFY
-          big_file = bucket.files.build
-          big_file.name = 'miasma-test-file-big'
-          big_file.body = big_file_content
-          big_file.save
-          big_file.reload
-
-          # should be the correct size
-          big_file.size.must_equal big_file.size
-          # should provide streaming body
-          big_file.body.must_respond_to :readpartial
-          content = big_file.body.readpartial(big_file.size)
-          content.must_equal big_file_content
-          big_file.destroy
-
-          require 'tempfile'
-          local_io_file = Tempfile.new('miasma-storage-test')
-          big_io_content = '*' * (Miasma::Models::Storage::MAX_BODY_SIZE_FOR_STRINGIFY * 2)
-          local_io_file.write big_io_content
-          local_io_file.flush
-          local_io_file.rewind
-          remote_file = bucket.files.build
-          remote_file.name = 'miasma-test-io-object-010'
-          remote_file.body = local_io_file
-          remote_file.save
-          remote_file.reload
-
-          # should be the correct size
-          remote_file.size.must_equal local_io_file.size
-          # should provide streaming body
-          remote_file.body.must_respond_to :readpartial
-          content = ''
-          while(chunk = remote_file.body.readpartial(1024))
-            content << chunk
-          end
-          content.must_equal big_io_content
-          remote_file.destroy
-          bucket.destroy
-        end
-
-      end
-
-
-    end
-
-  end
-}

data/test/specs/utils/animal_strings_spec.rb

@@ -1,15 +0,0 @@
-describe Miasma::Utils::AnimalStrings do
-
-  it 'should camel case strings' do
-    Miasma::Utils.camel('fubar_foobar_fuobar').must_equal 'FubarFoobarFuobar'
-  end
-
-  it 'should camel case symbols' do
-    Miasma::Utils.camel(:fubar_foobar_fuobar).must_equal 'FubarFoobarFuobar'
-  end
-
-  it 'should snake case strings' do
-    Miasma::Utils.snake('FubarFoobarFuobar').must_equal 'fubar_foobar_fuobar'
-  end
-
-end

data/test/specs/utils/memoization_spec.rb

@@ -1,83 +0,0 @@
-describe Miasma::Utils::Memoization do
-
-  before do
-    @memo = Object.new
-    @memo.extend Miasma::Utils::Memoization
-  end
-
-  after do
-    Thread.current[:miasma_memoization] = nil
-  end
-
-  let(:memo){ @memo }
-
-  it 'should #memoize the value returned by block' do
-    value = Kernel.rand
-    memo.memoize(:test) do
-      value
-    end.must_equal value
-    memo.memoize(:test){ Kernel.rand }.must_equal value
-  end
-
-  it 'should not return #memoize value from other instance' do
-    memo2 = Object.new
-    memo2.extend Miasma::Utils::Memoization
-    value = Kernel.rand
-    memo.memoize(:test) do
-      value
-    end.must_equal value
-    memo.memoize(:test){ Kernel.rand }.must_equal value
-    memo2.memoize(:test){ Kernel.rand }.wont_equal value
-  end
-
-  it 'should #unmemoize a memoized value' do
-    value = Kernel.rand
-    value2 = Kernel.rand
-    memo.memoize(:test) do
-      value
-    end.must_equal value
-    memo.unmemoize(:test)
-    memo.memoize(:test) do
-      value2
-    end.must_equal value2
-  end
-
-  it 'should allow direct #memoize not restricted to object' do
-    memo2 = Object.new
-    memo2.extend Miasma::Utils::Memoization
-    value = Kernel.rand
-    memo.memoize(:test, true) do
-      value
-    end.must_equal value
-    memo.memoize(:test, true){ Kernel.rand }.must_equal value
-    memo2.memoize(:test, true){ Kernal.rand }.must_equal value
-  end
-
-  it 'should clear all non-direct memoizations with #clear_memoizations!' do
-    memo2 = Object.new
-    memo2.extend Miasma::Utils::Memoization
-    value = Kernel.rand
-    memo.memoize(:test, true) do
-      value
-    end.must_equal value
-    memo.memoize(:test){ value }.must_equal value
-    memo2.memoize(:test){ value }.must_equal value
-
-    memo.memoize(:test, true){ Kernel.rand }.must_equal value
-    memo2.memoize(:test, true){ Kernel.rand }.must_equal value
-    memo.memoize(:test){ Kernel.rand }.must_equal value
-    memo2.memoize(:test){ Kernel.rand }.must_equal value
-
-    memo.clear_memoizations!
-    memo.memoize(:test){ Kernel.rand }.wont_equal value
-    memo2.memoize(:test){ Kernel.rand }.must_equal value
-
-    memo2.clear_memoizations!
-    memo.memoize(:test){ Kernel.rand }.wont_equal value
-    memo2.memoize(:test){ Kernel.rand }.wont_equal value
-
-    memo.memoize(:test, true){ Kernel.rand }.must_equal value
-    memo2.memoize(:test, true){ Kernel.rand }.must_equal value
-  end
-
-end

data/test/specs/utils/smash_spec.rb

@@ -1,107 +0,0 @@
-describe Miasma::Utils::Smash do
-
-  it 'should provide top level constant' do
-    defined?(::Smash).wont_be_nil
-  end
-
-  it 'should provide #to_smash on Hash' do
-    Hash.instance_methods.must_include :to_smash
-  end
-
-  it 'should convert Hash to Smash' do
-    {:a => 1}.to_smash.must_equal Smash.new(:a => 1)
-  end
-
-  it 'should sort keys when converting' do
-    hash = {:z => 1, :d => 3, :m => 1}
-    smash = Smash.new(:d => 3, :m => 1, :z => 1)
-    hash.to_smash.must_equal smash
-  end
-
-  it 'should convert deep nested Hashes to Smashes' do
-    hash = {
-      :a => 1,
-      :b => [
-        {:c => 2},
-        {:d => 3}
-      ]
-    }
-    smash = Smash.new(
-      :a => 1,
-      :b => [
-        Smash.new(:c => 2),
-        Smash.new(:d => 3)
-      ]
-    )
-    hash.to_smash.must_equal smash
-  end
-
-  it 'should #get deeply nested value' do
-    smash = {
-      :a => {
-        :b => {
-          :c => {
-            :d => 1
-          }
-        }
-      }
-    }.to_smash
-    smash.get(:a, :b, :c, :d).must_equal 1
-  end
-
-  it 'should #get nil on missing deeply nested value' do
-    smash = {
-      :a => {
-        :b => {
-          :c => {
-            :d => 1
-          }
-        }
-      }
-    }.to_smash
-    smash.get(:a, :b, :c, :x).must_be_nil
-  end
-
-  it 'should #set deeply nested value' do
-    smash = Smash.new
-    smash.set(:a, :b, :c, 1)
-    smash.get(:a, :b, :c).must_equal 1
-  end
-
-  it 'should #fetch default value on missing' do
-    smash = {
-      :a => {
-        :b => {
-          :c => {
-            :d => 1
-          }
-        }
-      }
-    }.to_smash
-    smash.fetch(:a, :b, :c, :x, 1).must_equal 1
-  end
-
-  it 'should #fetch value when availble' do
-    smash = {
-      :a => {
-        :b => {
-          :c => {
-            :d => 1
-          }
-        }
-      }
-    }.to_smash
-    smash.fetch(:a, :b, :c, :d, 0).must_equal 1
-  end
-
-  it 'should generate a #checksum' do
-    Smash.new(:a => 1).checksum.must_be_kind_of String
-  end
-
-  it 'should generate equal #checksum' do
-    hash = {:z => 1, :d => 3}
-    smash = Smash.new(:d => 3, :z => 1)
-    hash.to_smash.checksum.must_equal smash.checksum
-  end
-
-end