koala 0.9.0 → 1.1.0

data/spec/support/graph_api_shared_examples.rb

@@ -0,0 +1,495 @@
+shared_examples_for "Koala GraphAPI" do
+  # all Graph API instances should pass these tests, regardless of configuration
+
+  # API
+  it "should never use the rest api server" do
+    Koala.should_receive(:make_request).with(
+      anything,
+      anything,
+      anything,
+      hash_not_including(:rest_api => true)
+    ).and_return(Koala::Response.new(200, "", {}))
+
+    @api.api("anything")
+  end
+
+  # GRAPH CALL
+  describe "graph_call" do
+    it "should pass all arguments to the api method" do
+      args = ["koppel", {}, "get", {:a => :b}]
+
+      @api.should_receive(:api).with(*args)
+
+      @api.graph_call(*args)
+    end
+
+    it "should throw an APIError if the result hash has an error key" do
+      Koala.stub(:make_request).and_return(Koala::Response.new(500, {"error" => "An error occurred!"}, {}))
+      lambda { @api.graph_call("koppel", {}) }.should raise_exception(Koala::Facebook::APIError)
+    end
+  end
+
+  # SEARCH
+  it "should be able to search" do
+    result = @api.search("facebook")
+    result.length.should be_an(Integer)
+  end
+
+  # DATA
+  # access public info
+
+  # get_object
+  it "should get public data about a user" do
+    result = @api.get_object("koppel")
+    # the results should have an ID and a name, among other things
+    (result["id"] && result["name"]).should_not be_nil
+  end
+
+  it "should get public data about a Page" do
+    result = @api.get_object("contextoptional")
+    # the results should have an ID and a name, among other things
+    (result["id"] && result["name"]).should
+  end
+
+  it "should return [] from get_objects if passed an empty array" do
+    results = @api.get_objects([])
+    results.should == []
+  end
+  
+  it "should be able to get multiple objects" do
+    results = @api.get_objects(["contextoptional", "naitik"])
+    results.should have(2).items
+  end
+
+  it "should be able to get multiple objects if they're a string" do
+    results = @api.get_objects("contextoptional,naitik")
+    results.should have(2).items
+  end
+
+  it "should be able to access a user's picture" do
+    @api.get_picture("chris.baclig").should =~ /http[s]*\:\/\//
+  end
+
+  it "should be able to access a user's picture, given a picture type"  do
+    @api.get_picture("lukeshepard", {:type => 'large'}).should =~ /^http[s]*\:\/\//
+  end
+
+  it "should be able to access connections from public Pages" do
+    result = @api.get_connections("contextoptional", "photos")
+    result.should be_a(Array)
+  end
+
+  it "should be able to access comments for a URL" do
+    result = @api.get_comments_for_urls(["http://developers.facebook.com/blog/post/472"])
+    (result["http://developers.facebook.com/blog/post/472"]).should
+  end
+
+  it "should be able to access comments for 2 URLs" do
+    result = @api.get_comments_for_urls(["http://developers.facebook.com/blog/post/490", "http://developers.facebook.com/blog/post/472"])
+    (result["http://developers.facebook.com/blog/post/490"] && result["http://developers.facebook.com/blog/post/472"]).should
+  end
+
+  # SEARCH
+  it "should be able to search" do
+    result = @api.search("facebook")
+    result.length.should be_an(Integer)
+  end
+
+  # PAGING THROUGH COLLECTIONS
+  # see also graph_collection_tests
+  it "should make a request for a page when provided a specific set of page params" do
+    query = [1, 2]
+    @api.should_receive(:graph_call).with(*query)
+    @api.get_page(query)
+  end
+end
+
+
+shared_examples_for "Koala GraphAPI with an access token" do
+  it "should get private data about a user" do
+    result = @api.get_object("koppel")
+    # updated_time should be a pretty fixed test case
+    result["updated_time"].should_not be_nil
+  end
+
+  it "should get data about 'me'" do
+    result = @api.get_object("me")
+    result["updated_time"].should
+  end
+
+  it "should be able to get multiple objects" do
+    result = @api.get_objects(["contextoptional", "naitik"])
+    result.length.should == 2
+  end
+  it "should be able to access connections from users" do
+    result = @api.get_connections("lukeshepard", "likes")
+    result.length.should > 0
+  end
+
+  # PUT
+  it "should be able to write an object to the graph" do
+    result = @api.put_wall_post("Hello, world, from the test suite!")
+    @temporary_object_id = result["id"]
+    @temporary_object_id.should_not be_nil
+  end
+
+  # DELETE
+  it "should be able to delete posts" do
+    result = @api.put_wall_post("Hello, world, from the test suite delete method!")
+    object_id_to_delete = result["id"]
+    delete_result = @api.delete_object(object_id_to_delete)
+    delete_result.should == true
+  end
+
+  it "should be able to delete likes" do
+    result = @api.put_wall_post("Hello, world, from the test suite delete method!")
+    @temporary_object_id = result["id"]
+    @api.put_like(@temporary_object_id)
+    delete_like_result = @api.delete_like(@temporary_object_id)
+    delete_like_result.should == true
+  end
+
+  # additional put tests
+  it "should be able to verify messages posted to a wall" do
+    message = "the cats are asleep"
+    put_result = @api.put_wall_post(message)
+    @temporary_object_id = put_result["id"]
+    get_result = @api.get_object(@temporary_object_id)
+
+    # make sure the message we sent is the message that got posted
+    get_result["message"].should == message
+  end
+
+  it "should be able to post a message with an attachment to a feed" do
+    result = @api.put_wall_post("Hello, world, from the test suite again!", {:name => "OAuth Playground", :link => "http://oauth.twoalex.com/"})
+    @temporary_object_id = result["id"]
+    @temporary_object_id.should_not be_nil
+  end
+
+  describe ".put_picture" do
+    it "should be able to post photos to the user's wall with an open file object" do
+      content_type = "image/jpg"      
+      file = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
+  
+      result = @api.put_picture(file, content_type)
+      @temporary_object_id = result["id"] 
+      @temporary_object_id.should_not be_nil
+    end
+
+    it "uses the base HTTP service if the upload is a StringIO or similar" do
+      source = stub("UploadIO")
+      Koala::UploadableIO.stub(:new).and_return(source)
+      source.stub(:requires_base_http_service).and_return(true)
+      Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:http_service => Koala.base_http_service)).and_return(Koala::Response.new(200, "[]", {}))
+      @api.put_picture(StringIO.new)
+    end
+
+    it "should be able to post photos to the user's wall without an open file object" do
+      content_type = "image/jpg",
+      file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
+  
+      result = @api.put_picture(file_path, content_type)
+      @temporary_object_id = result["id"] 
+      @temporary_object_id.should_not be_nil
+    end
+  
+    it "should be able to verify a photo posted to a user's wall" do
+      content_type = "image/jpg",
+      file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
+  
+      expected_message = "This is the test message"
+  
+      result = @api.put_picture(file_path, content_type, :message => expected_message)
+      @temporary_object_id = result["id"] 
+      @temporary_object_id.should_not be_nil
+  
+      get_result = @api.get_object(@temporary_object_id)
+      get_result["name"].should == expected_message
+    end
+  end
+  
+  describe ".put_video" do
+    before :each do
+      @cat_movie = File.join(File.dirname(__FILE__), "..", "fixtures", "cat.m4v")      
+      @content_type = "video/mpeg4"      
+    end
+    
+    it "should set options[:video] to true" do
+      source = stub("UploadIO")
+      Koala::UploadableIO.stub(:new).and_return(source)
+      source.stub(:requires_base_http_service).and_return(false)
+      Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:video => true)).and_return(Koala::Response.new(200, "[]", {}))
+      @api.put_video("foo")
+    end
+    
+    it "should be able to post videos to the user's wall with an open file object" do
+      file = File.open(@cat_movie)
+
+      result = @api.put_video(file, @content_type)
+      @temporary_object_id = result["id"] 
+      @temporary_object_id.should_not be_nil
+    end
+
+    it "uses the base HTTP service if the upload is a StringIO or similar" do
+      source = stub("UploadIO")
+      Koala::UploadableIO.stub(:new).and_return(source)
+      source.stub(:requires_base_http_service).and_return(true)
+      Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:http_service => Koala.base_http_service)).and_return(Koala::Response.new(200, "[]", {}))
+      @api.put_video(StringIO.new)
+    end
+
+    it "should be able to post videos to the user's wall without an open file object" do
+      result = @api.put_video(@cat_movie, @content_type)
+      @temporary_object_id = result["id"] 
+      @temporary_object_id.should_not be_nil
+    end
+
+    # note: Facebook doesn't post videos immediately to the wall, due to processing time
+    # during which get_object(video_id) will return false
+    # hence we can't do the same verify test we do for photos
+  end
+
+  it "should be able to verify a message with an attachment posted to a feed" do
+    attachment = {"name" => "OAuth Playground", "link" => "http://oauth.twoalex.com/"}
+    result = @api.put_wall_post("Hello, world, from the test suite again!", attachment)
+    @temporary_object_id = result["id"]
+    get_result = @api.get_object(@temporary_object_id)
+
+    # make sure the result we fetch includes all the parameters we sent
+    it_matches = attachment.inject(true) {|valid, param| valid && (get_result[param[0]] == attachment[param[0]])}
+    it_matches.should == true
+  end
+
+  it "should be able to comment on an object" do
+    result = @api.put_wall_post("Hello, world, from the test suite, testing comments!")
+    @temporary_object_id = result["id"]
+
+    # this will be deleted when the post gets deleted
+    comment_result = @api.put_comment(@temporary_object_id, "it's my comment!")
+    comment_result.should_not be_nil
+  end
+
+  it "should be able to verify a comment posted about an object" do
+    message_text = "Hello, world, from the test suite, testing comments!"
+    result = @api.put_wall_post(message_text)
+    @temporary_object_id = result["id"]
+
+    # this will be deleted when the post gets deleted
+    comment_text = "it's my comment!"
+    comment_result = @api.put_comment(@temporary_object_id, comment_text)
+    get_result = @api.get_object(comment_result["id"])
+
+    # make sure the text of the comment matches what we sent
+    get_result["message"].should == comment_text
+  end
+
+  it "should be able to like an object" do
+    result = @api.put_wall_post("Hello, world, from the test suite, testing comments!")
+    @temporary_object_id = result["id"]
+    like_result = @api.put_like(@temporary_object_id)
+    like_result.should be_true
+  end
+
+
+  # test all methods to make sure they pass data through to the API
+  # we run the tests here (rather than in the common shared example group)
+  # since some require access tokens
+  describe "HTTP options" do
+    # Each of the below methods should take an options hash as their last argument
+    # ideally we'd use introspection to determine how many arguments a method has
+    # but some methods require specially formatted arguments for processing
+    # (and anyway, Ruby 1.8's arity method fails (for this) for methods w/ 2+ optional arguments)
+    # (Ruby 1.9's parameters method is perfect, but only in 1.9)
+    # so we have to double-document
+    {
+      :get_object => 3, :put_object => 4, :delete_object => 2,
+      :get_connections => 4, :put_connections => 4, :delete_connections => 4,
+      :put_wall_post => 4,
+      :put_comment => 3,
+      :put_like => 2, :delete_like => 2,
+      :search => 3,
+      # methods that have special arguments
+      :put_picture => ["x.jpg", "image/jpg", {}, "me"],
+      :put_video => ["x.mp4", "video/mpeg4", {}, "me"],
+      :get_objects => [["x"], {}]
+    }.each_pair do |method_name, params|
+      it "should pass http options through for #{method_name}" do
+        options = {:a => 2}
+        # graph call should ultimately receive options as the fourth argument
+        @api.should_receive(:graph_call).with(anything, anything, anything, options)
+
+        # if we supply args, use them (since some methods process params)
+        # the method should receive as args n-1 anythings and then options
+        args = (params.is_a?(Integer) ? ([{}] * (params - 1)) : params) + [options]
+
+        @api.send(method_name, *args)
+      end
+    end
+
+    # also test get_picture, which merges a parameter into options
+    it "should pass http options through for get_picture" do
+      options = {:a => 2}
+      # graph call should ultimately receive options as the fourth argument
+      @api.should_receive(:graph_call).with(anything, anything, anything, hash_including(options)).and_return({})
+      @api.send(:get_picture, "x", {}, options)
+    end
+  end
+end
+
+
+# GraphCollection
+shared_examples_for "Koala GraphAPI with GraphCollection" do
+
+  it "should create an array-like object" do
+    call = @api.graph_call("contextoptional/photos")
+    Koala::Facebook::GraphCollection.new(call, @api).should be_an(Array)
+  end
+
+  describe "when getting a collection" do
+    # GraphCollection methods
+    it "should get a GraphCollection when getting connections" do
+      @result = @api.get_connections("contextoptional", "photos")
+      @result.should be_a(Koala::Facebook::GraphCollection)
+    end
+
+    it "should return nil if the get_collections call fails with nil" do
+      # this happens sometimes
+      @api.should_receive(:graph_call).and_return(nil)
+      @api.get_connections("contextoptional", "photos").should be_nil
+    end
+
+    it "should get a GraphCollection when searching" do
+      result = @api.search("facebook")
+      result.should be_a(Koala::Facebook::GraphCollection)
+    end
+
+    it "should return nil if the search call fails with nil" do
+      # this happens sometimes
+      @api.should_receive(:graph_call).and_return(nil)
+      @api.search("facebook").should be_nil
+    end
+
+    it "should get a GraphCollection when paging through results" do
+      @results = @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=>"2010-09-23T21:17:33+0000"}])
+      @results.should be_a(Koala::Facebook::GraphCollection)
+    end
+
+    it "should return nil if the page call fails with nil" do
+      # this happens sometimes
+      @api.should_receive(:graph_call).and_return(nil)
+      @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=>"2010-09-23T21:17:33+0000"}]).should be_nil
+    end
+
+    # GraphCollection attributes
+    describe "the GraphCollection" do
+      before(:each) do
+        @result = @api.get_connections("contextoptional", "photos")
+      end
+
+      it "should have a read-only paging attribute" do
+        @result.methods.map(&:to_sym).should include(:paging)
+        @result.methods.map(&:to_sym).should_not include(:paging=)
+      end
+
+      describe "when getting a whole page" do
+        before(:each) do
+          @second_page = stub("page of Fb graph results")
+          @base = stub("base")
+          @args = stub("args")
+          @page_of_results = stub("page of results")
+        end
+
+        it "should return the previous page of results" do
+          @result.should_receive(:previous_page_params).and_return([@base, @args])
+          @api.should_receive(:graph_call).with(@base, @args).and_yield(@second_page)
+          Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
+
+          @result.previous_page#.should == @page_of_results
+        end
+
+        it "should return the next page of results" do
+          @result.should_receive(:next_page_params).and_return([@base, @args])
+          @api.should_receive(:graph_call).with(@base, @args).and_yield(@second_page)
+          Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
+
+          @result.next_page#.should == @page_of_results
+        end
+
+        it "should return nil it there are no other pages" do
+          %w{next previous}.each do |this|
+            @result.should_receive("#{this}_page_params".to_sym).and_return(nil)
+            @result.send("#{this}_page").should == nil
+          end
+        end
+      end
+
+      describe "when parsing page paramters" do
+        before(:each) do
+          @graph_collection = Koala::Facebook::GraphCollection.new({"data" => []}, Koala::Facebook::GraphAPI.new)
+        end
+
+        it "should return the base as the first array entry" do
+          base = "url_path"
+          @graph_collection.parse_page_url("anything.com/#{base}?anything").first.should == base
+        end
+
+        it "should return the arguments as a hash as the last array entry" do
+          args_hash = {"one" => "val_one", "two" => "val_two"}
+          @graph_collection.parse_page_url("anything.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
+        end
+      end
+    end
+  end
+end
+
+
+shared_examples_for "Koala GraphAPI without an access token" do
+
+  it "should not get private data about a user" do
+    result = @api.get_object("koppel")
+    # updated_time should be a pretty fixed test case
+    result["updated_time"].should be_nil
+  end
+
+  it "should not be able to get data about 'me'" do
+    lambda { @api.get_object("me") }.should raise_error(Koala::Facebook::APIError)
+  end
+
+  it "shouldn't be able to access connections from users" do
+    lambda { @api.get_connections("lukeshepard", "likes") }.should raise_error(Koala::Facebook::APIError)
+  end
+
+  it "should not be able to put an object" do
+    lambda { @result = @api.put_object("lukeshepard", "feed", :message => "Hello, world") }.should raise_error(Koala::Facebook::APIError)
+    puts "Error!  Object #{@result.inspect} somehow put onto Luke Shepard's wall!" if @result
+  end
+
+  # these are not strictly necessary as the other put methods resolve to put_object, but are here for completeness
+  it "should not be able to post to a feed" do
+    (lambda do
+      attachment = {:name => "OAuth Playground", :link => "http://oauth.twoalex.com/"}
+      @result = @api.put_wall_post("Hello, world", attachment, "contextoptional")
+    end).should raise_error(Koala::Facebook::APIError)
+    puts "Error!  Object #{@result.inspect} somehow put onto Context Optional's wall!" if @result
+  end
+
+  it "should not be able to comment on an object" do
+    # random public post on the ContextOptional wall
+    lambda { @result = @api.put_comment("7204941866_119776748033392", "The hackathon was great!") }.should raise_error(Koala::Facebook::APIError)
+    puts "Error!  Object #{@result.inspect} somehow commented on post 7204941866_119776748033392!" if @result
+  end
+
+  it "should not be able to like an object" do
+    lambda { @api.put_like("7204941866_119776748033392") }.should raise_error(Koala::Facebook::APIError)
+  end
+
+  # DELETE
+  it "should not be able to delete posts" do
+    # test post on the Ruby SDK Test application
+    lambda { @result = @api.delete_object("115349521819193_113815981982767") }.should raise_error(Koala::Facebook::APIError)
+  end
+
+  it "should not be able to delete a like" do
+    lambda { @api.delete_like("7204941866_119776748033392") }.should raise_error(Koala::Facebook::APIError)
+  end
+end

data/spec/support/json_testing_fix.rb

@@ -0,0 +1,18 @@
+# when testing across Ruby versions, we found that JSON string creation inconsistently ordered keys
+# which is a problem because our mock testing service ultimately matches strings to see if requests are mocked
+# this fix solves that problem by ensuring all hashes are created with a consistent key order every time
+
+module MultiJson
+  self.engine = :ok_json
+  
+  def encode_with_ordering(object)
+    # if it's a hash, recreate it with k/v pairs inserted in sorted-by-key order
+    # (for some reason, REE 1.8.7 fails if we don't assign the ternary result as a local variable 
+    # separate from calling encode_original)
+    new_object = object.is_a?(Hash) ? object.keys.sort.inject({}) {|hash, k| hash[k] = object[k]; hash} : object
+    encode_original(new_object)
+  end
+  
+  alias_method :encode_original, :encode
+  alias_method :encode, :encode_with_ordering
+end

data/spec/support/live_testing_data_helper.rb

@@ -0,0 +1,40 @@
+module LiveTestingDataHelper
+  # in RSpec 2, included example groups no longer share any hooks or state with outside examples
+  # even if in the same block
+  # so we have to use a module to provide setup and teardown hooks for live testing
+
+  def self.included(base)
+    base.class_eval do
+      before :each do
+        @token = $testing_data["oauth_token"]
+        raise Exception, "Must supply access token to run FacebookWithAccessTokenTests!" unless @token
+        # track temporary objects created
+        @temporary_object_ids = []
+      end
+
+      after :each do
+        # clean up any temporary objects
+        @temporary_object_ids << @temporary_object_id if @temporary_object_id
+        count = @temporary_object_ids.length
+        errors = []
+
+        if count > 0
+          @temporary_object_ids.each do |id|
+            # get our API
+            api = @api || (@test_users ? @test_users.graph_api : nil)
+            raise "Unable to locate API when passed temporary object to delete!" unless api
+
+            # delete the object
+            result = (api.delete_object(id) rescue false)
+            # if we errored out or Facebook returned false, track that
+            errors << id unless result
+          end
+
+          unless errors.length == 0
+            puts "cleaned up #{count - errors.length} objects, but errored out on the following:\n #{errors.join(", ")}"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/mock_http_service.rb

@@ -0,0 +1,96 @@
+require 'erb'
+require 'yaml'
+
+module Koala
+  module MockHTTPService
+    include Koala::HTTPService
+
+    # fix our specs to use ok_json, so we always get the same results from to_json
+    MultiJson.engine = :ok_json
+
+    # Mocks all HTTP requests for with koala_spec_with_mocks.rb
+    # Mocked values to be included in TEST_DATA used in specs
+    ACCESS_TOKEN = '*'
+    APP_ACCESS_TOKEN = "**"
+    OAUTH_CODE = 'OAUTHCODE'
+
+    # Loads testing data
+    TEST_DATA = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'fixtures', 'facebook_data.yml'))
+    TEST_DATA.merge!('oauth_token' => Koala::MockHTTPService::ACCESS_TOKEN)
+    TEST_DATA['oauth_test_data'].merge!('code' => Koala::MockHTTPService::OAUTH_CODE)
+
+    # Useful in mock_facebook_responses.yml
+    OAUTH_DATA = TEST_DATA['oauth_test_data']
+    OAUTH_DATA.merge!({
+      'app_access_token' => APP_ACCESS_TOKEN,
+      'session_key' => "session_key",
+      'multiple_session_keys' => ["session_key", "session_key_2"]
+    })
+    APP_ID = OAUTH_DATA['app_id']
+    SECRET = OAUTH_DATA['secret']
+    SUBSCRIPTION_DATA = TEST_DATA["subscription_test_data"]
+
+    # Loads the mock response data via ERB to substitue values for TEST_DATA (see oauth/access_token)
+    mock_response_file_path = File.join(File.dirname(__FILE__), '..', 'fixtures', 'mock_facebook_responses.yml')
+    RESPONSES = YAML.load(ERB.new(IO.read(mock_response_file_path)).result(binding))
+
+    def self.make_request(path, args, verb, options = {})
+      path = 'root' if path == '' || path == '/'
+      verb ||= 'get'
+      server = options[:rest_api] ? 'rest_api' : 'graph_api'
+      token = args.delete('access_token') 
+      with_token = (token == ACCESS_TOKEN || token == APP_ACCESS_TOKEN) ? 'with_token' : 'no_token'
+
+      # Assume format is always JSON
+      args.delete('format')
+
+      # Create a hash key for the arguments
+      args = create_params_key(args)
+
+      begin
+        response = RESPONSES[server][path][args][verb][with_token]
+
+        # Raises an error of with_token/no_token key is missing
+        raise NoMethodError unless response
+
+        # create response class object
+        response_object = if response.is_a? String
+            Koala::Response.new(200, response, {})
+          else
+            Koala::Response.new(response["code"] || 200, response["body"] || "", response["headers"] || {})
+          end
+
+      rescue NoMethodError
+        # Raises an error message with the place in the data YML
+        # to place a mock as well as a URL to request from
+        # Facebook's servers for the actual data
+        # (Don't forget to replace ACCESS_TOKEN with a real access token)
+        data_trace = [server, path, args, verb, with_token] * ': '
+
+        args = args == 'no_args' ? '' : "#{args}&"
+        args += 'format=json'
+        args += "&access_token=#{ACCESS_TOKEN}" if with_token
+
+        raise "Missing a mock response for #{data_trace}\nAPI PATH: #{[path, args].join('?')}"
+      end
+
+      response_object
+    end
+
+    def self.mock?
+      true
+    end
+
+    protected
+    def self.create_params_key(params_hash)
+      if params_hash.empty?
+        'no_args'
+      else
+        params_hash.sort{ |a,b| a[0].to_s <=> b[0].to_s}.map do |arr|
+          arr[1] = '[FILE]' if arr[1].kind_of?(Koala::UploadableIO)
+          arr.join('=')
+        end.join('&')
+      end
+    end
+  end
+end