snapimage 0.0.6 → 0.1.0

data/spec/acceptance/upload_spec.rb

@@ -8,7 +8,7 @@ describe "Upload" do
     @local_root = File.join(RSpec.root, "storage")
     @image_path = File.join(RSpec.root, "support/assets/stub-300x200.png")
     @large_image_path = File.join(RSpec.root, "support/assets/stub-2048x100.png")
-    @resource_id = "abc/123"
+    @directory = "abc/123"
   end
 
   after do
@@ -23,61 +23,13 @@ describe "Upload" do
       SnapImage::Middleware.new(
         app,
         path: "/snapimage_api",
-        config: {
-          "primary_storage_server" => "local",
-          "storage_servers" => [
-            {
-              "name" => "local",
-              "type" => "LOCAL",
-              "local_root" => File.join(RSpec.root, "storage"),
-              "public_url" => "//example.com/images"
-            }
-          ]
-        }
+        config: { "directory" => File.join(RSpec.root, "storage") }
       )
     end
 
     context "upload a file" do
       before do
-        json = {
-          action: "generate_image",
-          resource_identifier: @resource_id,
-          response_content_type: "text/html",
-          response_template: "json = {{json}}"
-        }.to_json
-        post "/snapimage_api", "file" => Rack::Test::UploadedFile.new(@image_path, "image/png"), "json" => json
-      end
-
-      it "is successful" do
-        last_response.should be_successful
-        last_response["Content-Type"].should eq "text/html"
-        matches = last_response.body.match(/json = ({.*})/)
-        matches.should_not be_nil
-        matches.size.should eq 2
-        json = JSON.parse(matches[1])
-        json["status_code"].should eq 200
-        json["message"].should eq "Get Modified Image Successful"
-        json["image_url"].should match Regexp.new("^//example.com/images/abc/123/[a-z0-9]{8}-300x200.png$")
-        json["image_width"].should eq 300
-        json["image_height"].should eq 200
-      end
-
-      it "stores the image" do
-        matches = last_response.body.match(/json = ({.*})/)
-        json = JSON.parse(matches[1])
-        path = File.join(@local_root, @resource_id, File.basename(json["image_url"]))
-        File.exist?(path).should be_true
-      end
-    end
-
-    context "upload from URL" do
-      before do
-        json = {
-          action: "generate_image",
-          url: "http://snapeditor.com/assets/se_logo.png",
-          resource_identifier: @resource_id
-        }.to_json
-        post "/snapimage_api", "json" => json
+        post "/snapimage_api", "file" => Rack::Test::UploadedFile.new(@image_path, "image/png"), "directory" => @directory
       end
 
       it "is successful" do
@@ -85,151 +37,38 @@ describe "Upload" do
         last_response["Content-Type"].should eq "text/json"
         json = JSON.parse(last_response.body)
         json["status_code"].should eq 200
-        json["message"].should eq "Get Modified Image Successful"
-        json["image_url"].should match Regexp.new("^//example.com/images/abc/123/[a-z0-9]{8}-54x41.png$")
-        json["image_width"].should eq 54
-        json["image_height"].should eq 41
+        json["message"].should eq "Success"
       end
 
       it "stores the image" do
         json = JSON.parse(last_response.body)
-        path = File.join(@local_root, @resource_id, File.basename(json["image_url"]))
+        path = File.join(@local_root, @directory, File.basename(@image_path))
         File.exist?(path).should be_true
       end
     end
 
-    context "upload too large" do
-      before do
-        json = { action: "generate_image", resource_identifier: @resource_id }.to_json
-        post "/snapimage_api", "file" => Rack::Test::UploadedFile.new(@large_image_path, "image/png"), "json" => json
-      end
-
-      it "resizes successfully" do
-        last_response.should be_successful
-        last_response["Content-Type"].should eq "text/json"
-        json = JSON.parse(last_response.body)
-        json["status_code"].should eq 200
-        json["message"].should eq "Get Modified Image Successful"
-        json["image_url"].should match Regexp.new("^//example.com/images/abc/123/[a-z0-9]{8}-1024x50.png$")
-        json["image_width"].should eq 1024
-        json["image_height"].should eq 50
-      end
-
-      it "stores the image" do
-        json = JSON.parse(last_response.body)
-        path = File.join(@local_root, @resource_id, File.basename(json["image_url"]))
-        File.exist?(path).should be_true
-      end
-    end
-  end
-
-  context "with security tokens" do
-    def app
-      app = Proc.new do |env|
-        [200, {}, ""]
-      end
-      SnapImage::Middleware.new(
-        app,
-        path: "/snapimage_api",
-        config: {
-          "security_salt" => "123456789",
-          "primary_storage_server" => "local",
-          "storage_servers" => [
-            {
-              "name" => "local",
-              "type" => "LOCAL",
-              "local_root" => File.join(RSpec.root, "storage"),
-              "public_url" => "//example.com/images"
-            }
-          ]
-        }
-      )
-    end
-
-    before do
-      @security_token = Digest::SHA1.hexdigest("client:#{Time.now.strftime("%Y-%m-%d")}:123456789:#{@resource_id}")
-    end
-
-    context "upload a file" do
-      before do
-        @options = { action: "generate_image", resource_identifier: @resource_id }
-      end
-
-      it "requires authorization when no security token is provided" do
-        request_json = @options.to_json
-        post "/snapimage_api", "file" => Rack::Test::UploadedFile.new(@image_path, "image/png"), "json" => request_json
-        last_response.should be_successful
-        last_response["content-type"].should eq "text/json"
-        json = JSON.parse(last_response.body)
-        json["status_code"].should eq 401
-        json["message"].should eq "Authorization Required"
-      end
-
-      it "fails authorization when the security token is invalid" do
-        request_json = @options.merge!({"client_security_token" => "abc"}).to_json
-        post "/snapimage_api", "file" => Rack::Test::UploadedFile.new(@image_path, "image/png"), "json" => request_json
-        last_response.should be_successful
-        last_response["content-type"].should eq "text/json"
-        json = JSON.parse(last_response.body)
-        json["status_code"].should eq 402
-        json["message"].should eq "Authorization Failed"
-      end
-
-      it "is successful when the security token is valid" do
-        request_json = @options.merge!({"client_security_token" => @security_token}).to_json
-        post "/snapimage_api", "file" => Rack::Test::UploadedFile.new(@image_path, "image/png"), "json" => request_json
-        last_response.should be_successful
-        last_response["content-type"].should eq "text/json"
-        json = JSON.parse(last_response.body)
-        json["status_code"].should eq 200
-        json["message"].should eq "Get Modified Image Successful"
-        json["image_url"].should match Regexp.new("^//example.com/images/abc/123/[a-z0-9]{8}-300x200.png$")
-        json["image_width"].should eq 300
-        json["image_height"].should eq 200
-      end
-    end
-
-    context "upload from URL" do
-      before do
-        @options = {
-          action: "generate_image",
-          url: "http://snapeditor.com/assets/se_logo.png",
-          resource_identifier: @resource_id
-        }
-      end
-
-      it "requires authorization when no security token is provided" do
-        request_json = @options.to_json
-        post "/snapimage_api", "file" => Rack::Test::UploadedFile.new(@image_path, "image/png"), "json" => request_json
-        last_response.should be_successful
-        last_response["content-type"].should eq "text/json"
-        json = JSON.parse(last_response.body)
-        json["status_code"].should eq 401
-        json["message"].should eq "Authorization Required"
-      end
-
-      it "fails authorization when the security token is invalid" do
-        request_json = @options.merge!({"client_security_token" => "abc"}).to_json
-        post "/snapimage_api", "file" => Rack::Test::UploadedFile.new(@image_path, "image/png"), "json" => request_json
-        last_response.should be_successful
-        last_response["content-type"].should eq "text/json"
-        json = JSON.parse(last_response.body)
-        json["status_code"].should eq 402
-        json["message"].should eq "Authorization Failed"
-      end
-
-      it "is successful" do
-        request_json = @options.merge!({"client_security_token" => @security_token}).to_json
-        post "/snapimage_api", "json" => request_json
-        last_response.should be_successful
-        last_response["Content-Type"].should eq "text/json"
-        json = JSON.parse(last_response.body)
-        json["status_code"].should eq 200
-        json["message"].should eq "Get Modified Image Successful"
-        json["image_url"].should match Regexp.new("^//example.com/images/abc/123/[a-z0-9]{8}-54x41.png$")
-        json["image_width"].should eq 54
-        json["image_height"].should eq 41
-      end
-    end
+    #context "upload too large" do
+      #before do
+        #json = { action: "generate_image", resource_identifier: @resource_id }.to_json
+        #post "/snapimage_api", "file" => Rack::Test::UploadedFile.new(@large_image_path, "image/png"), "json" => json
+      #end
+
+      #it "resizes successfully" do
+        #last_response.should be_successful
+        #last_response["Content-Type"].should eq "text/json"
+        #json = JSON.parse(last_response.body)
+        #json["status_code"].should eq 200
+        #json["message"].should eq "Get Modified Image Successful"
+        #json["image_url"].should match Regexp.new("^//example.com/images/abc/123/[a-z0-9]{8}-1024x50.png$")
+        #json["image_width"].should eq 1024
+        #json["image_height"].should eq 50
+      #end
+
+      #it "stores the image" do
+        #json = JSON.parse(last_response.body)
+        #path = File.join(@local_root, @resource_id, File.basename(json["image_url"]))
+        #File.exist?(path).should be_true
+      #end
+    #end
   end
 end

data/spec/snapimage/config_spec.rb

@@ -20,23 +20,15 @@ describe SnapImage::Config do
     it "returns the config from a YAML file" do
       config = SnapImage::Config.new(File.join(RSpec.root, "support/assets/config.yml"))
       c = config.get_config
-      c["security_salt"].should eq "abc123"
-      c["storage_servers"].length.should eq 2
-      c["storage_servers"][0]["name"].should eq "storage 1"
-      c["storage_servers"][0]["type"].should eq "test"
-      c["storage_servers"][1]["name"].should eq "storage 2"
-      c["storage_servers"][1]["type"].should eq "test"
+      c["directory"].should eq "/path/to/directory"
+      c["max_file_size"].should eq 100
     end
 
     it "returns the config from a JSON file" do
       config = SnapImage::Config.new(File.join(RSpec.root, "support/assets/config.json"))
       c = config.get_config
-      c["security_salt"].should eq "abc123"
-      c["storage_servers"].length.should eq 2
-      c["storage_servers"][0]["name"].should eq "storage 1"
-      c["storage_servers"][0]["type"].should eq "test"
-      c["storage_servers"][1]["name"].should eq "storage 2"
-      c["storage_servers"][1]["type"].should eq "test"
+      c["directory"].should eq "/path/to/directory"
+      c["max_file_size"].should eq 100
     end
   end
 
@@ -46,7 +38,7 @@ describe SnapImage::Config do
     end
 
     it "returns the value when the key exists" do
-      @config["security_salt"].should eq "abc123"
+      @config["directory"].should eq "/path/to/directory"
     end
 
     it "returns nil when the key does not exist" do

data/spec/snapimage/image/image_name_utils_spec.rb

@@ -1,127 +1,127 @@
-require "spec_helper"
+#require "spec_helper"
 
-describe SnapImage::ImageNameUtils do
-  before do
-    @image_path = File.join(RSpec.root, "support/assets/stub.png")
-  end
+#describe SnapImage::ImageNameUtils do
+  #before do
+    #@image_path = File.join(RSpec.root, "support/assets/stub.png")
+  #end
 
-  describe "#get_image_type" do
-    it "returns the correct type" do
-      SnapImage::ImageNameUtils.get_image_type("http://example.com/storage/abc/123/image.png").should eq "png"
-    end
+  #describe "#get_image_type" do
+    #it "returns the correct type" do
+      #SnapImage::ImageNameUtils.get_image_type("http://example.com/storage/abc/123/image.png").should eq "png"
+    #end
 
-    it "returns jpg when the type is jpeg" do
-      SnapImage::ImageNameUtils.get_image_type("http://example.com/storage/abc/123/image.jpeg").should eq "jpg"
-    end
-  end
+    #it "returns jpg when the type is jpeg" do
+      #SnapImage::ImageNameUtils.get_image_type("http://example.com/storage/abc/123/image.jpeg").should eq "jpg"
+    #end
+  #end
 
-  describe "#get_image_name_parts" do
-    it "raises an error when the image identifier is invalid" do
-      expect { SnapImage::ImageNameUtils.get_image_name_parts("a bad url") }.should raise_error SnapImage::InvalidImageIdentifier
-    end
+  #describe "#get_image_name_parts" do
+    #it "raises an error when the image identifier is invalid" do
+      #expect { SnapImage::ImageNameUtils.get_image_name_parts("a bad url") }.should raise_error SnapImage::InvalidImageIdentifier
+    #end
 
-    it "returns all the parts given a base image url" do
-      url = "http://example.com/dkej2o3i-1024x768.png"
-      parts = SnapImage::ImageNameUtils.get_image_name_parts(url)
-      parts[:is_base].should be_true
-      parts[:full].should eq url
-      parts[:path].should eq "http://example.com"
-      parts[:filename].should eq "dkej2o3i-1024x768.png"
-      parts[:basename].should eq "dkej2o3i"
-      parts[:original_dimensions].should eq [1024, 768]
-      parts[:extname].should eq "png"
-      parts[:crop].should be_nil
-      parts[:dimensions].should be_nil
-      parts[:sharpen].should be_nil
-    end
+    #it "returns all the parts given a base image url" do
+      #url = "http://example.com/dkej2o3i-1024x768.png"
+      #parts = SnapImage::ImageNameUtils.get_image_name_parts(url)
+      #parts[:is_base].should be_true
+      #parts[:full].should eq url
+      #parts[:path].should eq "http://example.com"
+      #parts[:filename].should eq "dkej2o3i-1024x768.png"
+      #parts[:basename].should eq "dkej2o3i"
+      #parts[:original_dimensions].should eq [1024, 768]
+      #parts[:extname].should eq "png"
+      #parts[:crop].should be_nil
+      #parts[:dimensions].should be_nil
+      #parts[:sharpen].should be_nil
+    #end
 
-    it "returns all the parts given a modified image url" do
-      url = "http://example.com/dkej2o3i-1024x768-6x10x143x402-640x480-1.png"
-      parts = SnapImage::ImageNameUtils.get_image_name_parts(url)
-      parts[:is_base].should be_false
-      parts[:full].should eq url
-      parts[:path].should eq "http://example.com"
-      parts[:filename].should eq "dkej2o3i-1024x768-6x10x143x402-640x480-1.png"
-      parts[:basename].should eq "dkej2o3i"
-      parts[:original_dimensions].should eq [1024, 768]
-      parts[:crop][:x].should eq 6
-      parts[:crop][:y].should eq 10
-      parts[:crop][:width].should eq 143
-      parts[:crop][:height].should eq 402
-      parts[:dimensions].should eq [640, 480]
-      parts[:sharpen].should eq true
-      parts[:extname].should eq "png"
-    end
+    #it "returns all the parts given a modified image url" do
+      #url = "http://example.com/dkej2o3i-1024x768-6x10x143x402-640x480-1.png"
+      #parts = SnapImage::ImageNameUtils.get_image_name_parts(url)
+      #parts[:is_base].should be_false
+      #parts[:full].should eq url
+      #parts[:path].should eq "http://example.com"
+      #parts[:filename].should eq "dkej2o3i-1024x768-6x10x143x402-640x480-1.png"
+      #parts[:basename].should eq "dkej2o3i"
+      #parts[:original_dimensions].should eq [1024, 768]
+      #parts[:crop][:x].should eq 6
+      #parts[:crop][:y].should eq 10
+      #parts[:crop][:width].should eq 143
+      #parts[:crop][:height].should eq 402
+      #parts[:dimensions].should eq [640, 480]
+      #parts[:sharpen].should eq true
+      #parts[:extname].should eq "png"
+    #end
 
-    it "returns all the parts given a filename" do
-      url = "dkej2o3i-1024x768-6x10x143x402-640x480-1.png"
-      parts = SnapImage::ImageNameUtils.get_image_name_parts(url)
-      parts[:is_base].should be_false
-      parts[:full].should eq url
-      parts[:path].should eq ""
-      parts[:filename].should eq "dkej2o3i-1024x768-6x10x143x402-640x480-1.png"
-      parts[:basename].should eq "dkej2o3i"
-      parts[:original_dimensions].should eq [1024, 768]
-      parts[:crop][:x].should eq 6
-      parts[:crop][:y].should eq 10
-      parts[:crop][:width].should eq 143
-      parts[:crop][:height].should eq 402
-      parts[:dimensions].should eq [640, 480]
-      parts[:sharpen].should eq true
-      parts[:extname].should eq "png"
-    end
-  end
+    #it "returns all the parts given a filename" do
+      #url = "dkej2o3i-1024x768-6x10x143x402-640x480-1.png"
+      #parts = SnapImage::ImageNameUtils.get_image_name_parts(url)
+      #parts[:is_base].should be_false
+      #parts[:full].should eq url
+      #parts[:path].should eq ""
+      #parts[:filename].should eq "dkej2o3i-1024x768-6x10x143x402-640x480-1.png"
+      #parts[:basename].should eq "dkej2o3i"
+      #parts[:original_dimensions].should eq [1024, 768]
+      #parts[:crop][:x].should eq 6
+      #parts[:crop][:y].should eq 10
+      #parts[:crop][:width].should eq 143
+      #parts[:crop][:height].should eq 402
+      #parts[:dimensions].should eq [640, 480]
+      #parts[:sharpen].should eq true
+      #parts[:extname].should eq "png"
+    #end
+  #end
 
-  describe "#get_base_image_path" do
-    it "returns the base image name from the url" do
-      url = "http://example.com/dkej2o3i-1024x768-6x10x143x402-640x480-1.png"
-      SnapImage::ImageNameUtils.get_base_image_path(url).should eq "http://example.com/dkej2o3i-1024x768.png"
-    end
-  end
+  #describe "#get_base_image_path" do
+    #it "returns the base image name from the url" do
+      #url = "http://example.com/dkej2o3i-1024x768-6x10x143x402-640x480-1.png"
+      #SnapImage::ImageNameUtils.get_base_image_path(url).should eq "http://example.com/dkej2o3i-1024x768.png"
+    #end
+  #end
 
-  describe "#get_resized_image_name" do
-    it "returns the resized name given a base image" do
-      name = SnapImage::ImageNameUtils.get_resized_image_name("12345678-2048x100.png", 1024, 50)
-      name.should eq "12345678-1024x50.png"
-    end
+  #describe "#get_resized_image_name" do
+    #it "returns the resized name given a base image" do
+      #name = SnapImage::ImageNameUtils.get_resized_image_name("12345678-2048x100.png", 1024, 50)
+      #name.should eq "12345678-1024x50.png"
+    #end
 
-    it "returns the resized name given a modified image" do
-      name = SnapImage::ImageNameUtils.get_resized_image_name("12345678-1x1-0x0x1x1-2048x100-0.png", 1024, 50)
-      name.should eq "12345678-1x1-0x0x1x1-1024x50-0.png"
-    end
-  end
+    #it "returns the resized name given a modified image" do
+      #name = SnapImage::ImageNameUtils.get_resized_image_name("12345678-1x1-0x0x1x1-2048x100-0.png", 1024, 50)
+      #name.should eq "12345678-1x1-0x0x1x1-1024x50-0.png"
+    #end
+  #end
 
-  describe "#generate_basename" do
-    it "generates 8 random alphanumeric characters" do
-      SnapImage::ImageNameUtils.generate_basename.should match /^[a-z0-9]{8}$/
-    end
-  end
+  #describe "#generate_basename" do
+    #it "generates 8 random alphanumeric characters" do
+      #SnapImage::ImageNameUtils.generate_basename.should match /^[a-z0-9]{8}$/
+    #end
+  #end
 
-  describe "#generate_image_name" do
-    it "generates a base image name without options" do
-      SnapImage::ImageNameUtils.generate_image_name(1024, 768, "png").should match /[a-z0-9]{8}-1024x768\.png/
-    end
+  #describe "#generate_image_name" do
+    #it "generates a base image name without options" do
+      #SnapImage::ImageNameUtils.generate_image_name(1024, 768, "png").should match /[a-z0-9]{8}-1024x768\.png/
+    #end
 
-    it "generates a base image name with just a basename option" do
-      SnapImage::ImageNameUtils.generate_image_name(1024, 768, "png", basename: "test").should eq "test-1024x768.png"
-    end
+    #it "generates a base image name with just a basename option" do
+      #SnapImage::ImageNameUtils.generate_image_name(1024, 768, "png", basename: "test").should eq "test-1024x768.png"
+    #end
 
-    it "generates a modified image name with options" do
-      SnapImage::ImageNameUtils.generate_image_name(
-        1024,
-        768,
-        "png",
-        basename: "image",
-        crop: {
-          x: 6,
-          y: 7,
-          width: 134,
-          height: 350
-        },
-        width: 640,
-        height: 480,
-        sharpen: true
-      ).should eq "image-1024x768-6x7x134x350-640x480-1.png"
-    end
-  end
-end
+    #it "generates a modified image name with options" do
+      #SnapImage::ImageNameUtils.generate_image_name(
+        #1024,
+        #768,
+        #"png",
+        #basename: "image",
+        #crop: {
+          #x: 6,
+          #y: 7,
+          #width: 134,
+          #height: 350
+        #},
+        #width: 640,
+        #height: 480,
+        #sharpen: true
+      #).should eq "image-1024x768-6x7x134x350-640x480-1.png"
+    #end
+  #end
+#end