snapimage 0.0.1

data/spec/snapimage/server_actions/server_actions.generate_image_spec.rb

@@ -0,0 +1,146 @@
+require "spec_helper"
+
+describe SnapImage::ServerActions::GenerateImage do
+  before do
+    @image_path = File.join(RSpec.root, "support/assets/stub-300x200.png")
+    @storage = double("storage")
+    @config = { "max_width" => 1024, "max_height" => 2048 }
+    @config.stub(:storage).and_return(@storage)
+    @request = double("request")
+    @response = double("response")
+    @generate_image = SnapImage::ServerActions::GenerateImage.new(@config, @request, @response)
+  end
+
+  describe "#source_image_defined?" do
+    it "returns false if file and url are not defined" do
+      @request.stub(:file).and_return(nil)
+      @request.stub(:json).and_return({})
+      @generate_image.send(:source_image_defined?).should be_false
+    end
+
+    it "returns true when file is defined" do
+      @request.stub(:file).and_return("file")
+      @request.stub(:json).and_return({})
+      @generate_image.send(:source_image_defined?).should be_true
+    end
+
+    it "returns true when url is defined" do
+      @request.stub(:file).and_return(nil)
+      @request.stub(:json).and_return({"url" => "something"})
+      @generate_image.send(:source_image_defined?).should be_true
+    end
+  end
+
+  describe "#get_max_width?" do
+    it "returns the server max width when JSON 'max_width' is not defined" do
+      @request.stub(:json).and_return({})
+      @generate_image.send(:get_max_width).should eq 1024
+    end
+
+    it "returns the server max width when JSON 'max_width' is larger" do
+      @request.stub(:json).and_return({"max_width" => "4096"})
+      @generate_image.send(:get_max_width).should eq 1024
+    end
+
+    it "returns the JSON 'max_width' when server max width is larger" do
+      @request.stub(:json).and_return({"max_width" => "640"})
+      @generate_image.send(:get_max_width).should eq 640
+    end
+  end
+
+  describe "#get_max_height?" do
+    it "returns the server max height when JSON 'max_height' is not defined" do
+      @request.stub(:json).and_return({})
+      @generate_image.send(:get_max_height).should eq 2048
+    end
+
+    it "returns the server max height when JSON 'max_height' is larger" do
+      @request.stub(:json).and_return({"max_height" => "4096"})
+      @generate_image.send(:get_max_height).should eq 2048
+    end
+
+    it "returns the JSON 'max_height' when server max height is larger" do
+      @request.stub(:json).and_return({"max_height" => "640"})
+      @generate_image.send(:get_max_height).should eq 640
+    end
+  end
+
+  describe "#get_image_for_modification" do
+    context "upload" do
+      before do
+        @generate_image.stub(:upload?).and_return(true)
+      end
+
+      it "uploads the image and returns it when a file is specified" do
+        @request.stub(:file).and_return("file")
+        @request.stub(:json).and_return({"resource_identifier" => "abc123"})
+        @storage.should_receive(:add_upload).with("file", "abc123").once.and_return("image")
+        @generate_image.send(:get_image_for_modification).should eq "image"
+      end
+
+      it "downloads the image and returns it when a local url is specified" do
+        @request.stub(:file).and_return(nil)
+        @request.stub(:json).and_return({"url" => "http://example.com/12345678-1024x768.png", "resource_identifier" => "abc123"})
+        @storage.should_receive(:add_url).with("http://example.com/12345678-1024x768.png", "abc123").once.and_return("image")
+        @generate_image.send(:get_image_for_modification).should eq "image"
+      end
+    end
+
+    context "modify" do
+      before do
+        @generate_image.stub(:upload?).and_return(false)
+      end
+
+      it "gets the base image" do
+        @request.stub(:json).and_return("url" => "http://example.com/fi3k2od0-1027x768-1x2x640x480-300x200-1.png")
+        @storage.should_receive(:get).with("http://example.com/fi3k2od0-1027x768.png").once.and_return("image")
+        @generate_image.send(:get_image_for_modification).should eq "image"
+      end
+    end
+  end
+
+  describe "#modify_image" do
+    before do
+      @image = SnapImage::Image.from_path(@image_path, "http://example.com/12345678-300x200.png")
+    end
+
+    it "does nothing when there are no modifications" do
+      @request.stub(:json).and_return({})
+      result = @generate_image.send(:modify_image, @image)
+      result[:image].should be @image
+      result[:name].should eq "12345678-300x200.png"
+    end
+
+    it "crops" do
+      @request.stub(:json).and_return({"crop_x" => 10, "crop_y" => 20, "crop_width" => 50, "crop_height" => 100})
+      result = @generate_image.send(:modify_image, @image)
+      result[:image].width.should eq 50
+      result[:image].height.should eq 100
+      result[:name].should eq "12345678-300x200-10x20x50x100-50x100-0.png"
+    end
+
+    it "resizes" do
+      @request.stub(:json).and_return({"width" => 400, "height" => 50})
+      result = @generate_image.send(:modify_image, @image)
+      result[:image].width.should eq 400
+      result[:image].height.should eq 50
+      result[:name].should eq "12345678-300x200-0x0x300x200-400x50-0.png"
+    end
+
+    it "resizes to fit" do
+      @request.stub(:json).and_return({"width" => 2048, "height" => 100})
+      result = @generate_image.send(:modify_image, @image)
+      result[:image].width.should eq 1024
+      result[:image].height.should eq 50
+      result[:name].should eq "12345678-300x200-0x0x300x200-1024x50-0.png"
+    end
+
+    it "sharpens" do
+      @request.stub(:json).and_return({"sharpen" => true})
+      result = @generate_image.send(:modify_image, @image)
+      result[:image].width.should eq 300
+      result[:image].height.should eq 200
+      result[:name].should eq "12345678-300x200-0x0x300x200-300x200-1.png"
+    end
+  end
+end

data/spec/snapimage/server_actions/server_actions.sync_resource_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+
+describe SnapImage::ServerActions::SyncResource do
+  before do
+    @image_path = File.join(RSpec.root, "support/assets/stub-300x200.png")
+    @storage = double("storage")
+    @config = { "max_width" => 1024, "max_height" => 2048 }
+    @config.stub(:storage).and_return(@storage)
+    @request = double("request")
+    @response = double("response")
+    @sync_resource = SnapImage::ServerActions::SyncResource.new(@config, @request, @response)
+  end
+
+  describe "#request_valid?" do
+    it "returns false when content is not valid" do
+      @sync_resource.stub(:content_valid?).and_return(false)
+      @sync_resource.send(:request_valid?).should be_false
+    end
+
+    it "returns false when sync_date_time is not defined" do
+      @sync_resource.stub(:content_valid?).and_return(true)
+      @request.stub(:json).and_return({})
+      @sync_resource.send(:request_valid?).should be_false
+    end
+
+    it "returns true when the request is valid" do
+      @request.stub(:json).and_return({"sync_date_time" => DateTime.now.iso8601})
+      @sync_resource.stub(:content_valid?).and_return(true)
+      @sync_resource.send(:request_valid?).should be_true
+    end
+  end
+
+  describe "#content_valid?" do
+    it "returns false when content is not defined" do
+      @request.stub(:json).and_return({})
+      @sync_resource.send(:content_valid?).should be_false
+    end
+
+    it "returns false when content is not a hash" do
+      @request.stub(:json).and_return({"content" => "content"})
+      @sync_resource.send(:content_valid?).should be_false
+    end
+
+    it "returns false when content is empty" do
+      @request.stub(:json).and_return({"content" => {}})
+      @sync_resource.send(:content_valid?).should be_false
+    end
+
+    it "returns true when content is valid" do
+      @request.stub(:json).and_return({"content" => {"body" => "test"}})
+      @sync_resource.send(:content_valid?).should be_true
+    end
+  end
+
+  describe "#get_content" do
+    it "returns all the content concatenated" do
+      @request.stub(:json).and_return({"content" => {"first" => "hello", "second" => "world"}})
+      @sync_resource.send(:get_content).should eq "helloworld"
+    end
+  end
+
+  describe "#urls_to_keep" do
+    it "returns all urls that match" do
+      @storage.stub(:url_regexps).and_return([
+        /(\/\/example\.com\/storage\/.+?\.(png|gif|jpg))/,
+        /\/\/snapeditor\.com\/.+?\.(png|gif|jpg)/,
+        /\/\/my-bucket\.s3\.amazonaws\.com\/my-images\/.+?\.(png|gif|jpg)/
+      ])
+      url_1 = "http://example.com/storage/abc/123/12345678-1024x768.png"
+      url_2 = "http://snapeditor.com/abc/123/12345678-1024x768-10x40x200x300-400x500-0.gif"
+      url_3 = "//my-bucket.s3.amazonaws.com/my-images/abc/123/12345678-1024x768-10x40x200x300-400x500-0.jpg"
+      url_4 = "//my-bucket.s3.amazonaws.com/my-images/abc/123/12345678-1024x768-10x40x200x300-400x500-1.jpg"
+      @sync_resource.stub(:get_content).and_return(
+      <<-CONTENT
+        This is some fake content with images. <img src="#{url_1}" /><img src="http://example.com/abc/123/image.png" />
+        Some more ["#{url_2}"] but maybe not this http://snapeditor.com/.
+        #{url_3} and //my-bucket.s3.amazonaws.com/my-images/abc/123/image.jpeg and #{url_4}
+      CONTENT
+      )
+      keep = @sync_resource.send(:urls_to_keep)
+      keep.size.should eq 7
+      keep.include?(url_1)
+      keep.include?(url_2)
+      keep.include?(url_3)
+      keep.include?(url_4)
+      keep.include?("http://snapeditor.com/abc/123/12345678-1024x768.gif")
+      keep.include?("//my-bucket.s3.amazonaws.com/my-images/abc/123/12345678-1024x768.jpg")
+      keep.include?("//my-bucket.s3.amazonaws.com/my-images/abc/123/12345678-1024x768.jpg")
+    end
+  end
+end

data/spec/snapimage/server_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe SnapImage::Server do
+  before do
+    @request = double("request")
+    @config = double("config")
+    @config.stub(:storage).and_return("storage")
+    @server = SnapImage::Server.new(@request, @config)
+  end
+
+  describe "#call" do
+    it "returns a bad request when the request is bad" do
+      @request.stub(:bad_request?).and_return(true)
+      response = @server.call
+      response[0].should eq 200
+      response[1]["Content-Type"].should eq "text/json"
+      response[2].body.should eq ['{"status_code":400,"message":"Bad Request"}']
+    end
+
+    it "returns invalid resource identifier when the resource identifier is invalid" do
+      @request.stub(:bad_request?).and_return(false)
+      @request.stub(:json).and_return({"resource_identifier" => "abc?123"})
+      response = @server.call
+      response[0].should eq 200
+      response[1]["Content-Type"].should eq "text/json"
+      response[2].body.should eq ['{"status_code":404,"message":"Invalid Resource Identifier"}']
+    end
+
+    it "returns not implemented when the action does not exist" do
+      @request.stub(:bad_request?).and_return(false)
+      @request.stub(:json).and_return({"action" => "test", "resource_identifier" => "abc/123"})
+      response = @server.call
+      response[0].should eq 200
+      response[1]["Content-Type"].should eq "text/json"
+      response[2].body.should eq ['{"status_code":501,"message":"Not Implemented"}']
+    end
+
+    it "calls the action" do
+      response = double("response")
+      response.stub(:finish)
+      generate_image = double("Generate Image")
+      generate_image.should_receive(:call).once.and_return(response)
+      SnapImage::ServerActions::GenerateImage.stub(:new).and_return(generate_image)
+      @request.stub(:bad_request?).and_return(false)
+      @request.stub(:json).and_return({"action" => "generate_image", "resource_identifier" => "abc/123"})
+      @server.call
+    end
+  end
+
+  describe "#get_action_class" do
+    it "returns the correct class" do
+      @server.send(:get_action_class, "generate_image").should be SnapImage::ServerActions::GenerateImage
+    end
+  end
+end

data/spec/snapimage/storage/storage_server.local_spec.rb

@@ -0,0 +1,150 @@
+require "spec_helper"
+
+describe SnapImage::StorageServer::Local do
+  before do
+    @local_root = File.join(RSpec.root, "storage")
+    @image_path = File.join(RSpec.root, "support/assets/stub-1x1.png")
+    @server = SnapImage::StorageServer::Local.new(
+      "name" => "Test",
+      "public_url" => "//example.com/storage",
+      "local_root" => @local_root,
+      "max_width" => 1024,
+      "max_height" => 2048
+    )
+  end
+
+  after do
+    FileUtils.rm_rf(@local_root)
+  end
+
+  describe "#store_file" do
+    before do
+      SnapImage::ImageNameUtils.stub(:generate_image_name).and_return("test_image.png")
+      @file = File.new(@image_path, "rb")
+      @server.store_file(@file, "png", "abc/123")
+    end
+
+    it "copies the contents of the file" do
+      contents = File.new(File.join(@local_root, "abc/123/test_image.png"), "rb").read
+      blob = SnapImage::Image.from_blob(File.new(@image_path, "rb").read).blob
+      contents.should eq blob
+    end
+  end
+
+  describe "#get" do
+    before do
+      SnapImage::ImageNameUtils.stub(:generate_image_name).and_return("test_image.png")
+      @server.store_file(File.new(@image_path), "png", "abc/123")
+    end
+
+    it "raises an error when the file doesn't exist" do
+      expect { @server.get("http://example.com/storage/abc/123/test_image.gif") }.should raise_error SnapImage::FileDoesNotExist
+    end
+
+    it "returns a SnapImage::Image" do
+      image = @server.get("http://example.com/storage/abc/123/test_image.png")
+      image.is_a?(SnapImage::Image).should be_true
+    end
+  end
+
+  describe "#store" do
+    before do
+      SnapImage::ImageNameUtils.stub(:generate_image_name).and_return("test_image.png")
+      @image = @server.send(:store, SnapImage::Image.from_blob(File.new(@image_path, "rb").read), "test_image.png", "abc/123")
+    end
+
+    it "creates a new file in the storage" do
+      File.exists?(File.join(@local_root, "abc/123/test_image.png")).should be_true
+    end
+
+    it "writes the contents to the file" do
+      contents = File.new(File.join(@local_root, "abc/123/test_image.png"), "rb").read
+      blob = SnapImage::Image.from_blob(File.new(@image_path, "rb").read).blob
+      contents.should eq blob
+    end
+
+    it "returns the image" do
+      @image.is_a?(SnapImage::Image).should be_true
+      @image.public_url.should eq "//example.com/storage/abc/123/test_image.png"
+    end
+  end
+
+  describe "#root" do
+    it "creates the root when it doesn't exist" do
+      @server.send(:root)
+      File.directory?(@local_root)
+    end
+
+    it "returns the root" do
+      @server.send(:root).should eq @local_root
+    end
+  end
+
+  describe "#get_local_path_parts" do
+    it "returns nil when the the path is not a local path" do
+      @server.send(:get_local_path_parts, "some/random/path/image.png").should be_nil
+    end
+
+    it "returns the parts when the path is a local path" do
+      parts = @server.send(:get_local_path_parts, File.join(@local_root, "abc/123/image.png"))
+      parts[:resource_id].should eq "abc/123"
+      parts[:filename].should eq "image.png"
+    end
+  end
+
+  describe "#local_path_to_public_url" do
+    it "returns the public url corresponding to the local path" do
+      local_path = File.join(@local_root, "abc/123/image.png")
+      @server.send(:local_path_to_public_url, local_path).should eq "//example.com/storage/abc/123/image.png"
+    end
+  end
+
+  describe "#public_url_to_local_path" do
+    it "returns the local path corresponding to the public url" do
+      url = "http://example.com/storage/abc/123/image.png"
+      @server.send(:public_url_to_local_path, url).should eq File.join(@local_root, "abc/123/image.png")
+    end
+  end
+
+  describe "#get_resource_filenames" do
+    before do
+      @old_local_root = @local_root
+      @local_root = File.join(File.expand_path(File.dirname(__FILE__)), "assets/local")
+      @server = SnapImage::StorageServer::Local.new(
+        "name" => "Test",
+        "public_url" => "//example.com/storage",
+        "local_root" => @local_root,
+        "max_width" => 1024,
+        "max_height" => 2048
+      )
+    end
+
+    after do
+      @local_root = @old_local_root
+    end
+
+    it "returns only images for the given resource id" do
+      filenames = @server.send(:get_resource_filenames, "resource_1")
+      filenames.size.should eq 3
+      filenames.include?(File.join(@local_root, "resource_1/12345678-1x1.png")).should be_true
+      filenames.include?(File.join(@local_root, "resource_1/12345678-1x1-0x0x1x1-300x200-0.jpg")).should be_true
+      filenames.include?(File.join(@local_root, "resource_1/12345678-1x1-0x0x1x1-1x1-1.gif")).should be_true
+    end
+  end
+
+  describe "#file_modified_before_timestamp??" do
+    it "returns true when no timestamp is given" do
+      @server.send(:file_modified_before_timestamp?, @image_path).should be_true
+    end
+
+    it "returns true when the file was modified before the timestamp" do
+      timestamp = DateTime.parse(File.mtime(@image_path).iso8601) + 100
+      @server.send(:file_modified_before_timestamp?, @image_path, timestamp).should be_true
+    end
+
+    it "returns false when file was not modified before the timestamp" do
+      timestamp = DateTime.parse(File.mtime(@image_path).iso8601)
+      @server.send(:file_modified_before_timestamp?, @image_path, timestamp).should be_false
+    end
+  end
+end