berkshelf-store 0.2.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OWQ4NTk2YzFkM2Q5NDg5Y2Y1YTRhODIxYzM1ZjIwNDM1ZjkzYzVjNg==
+  data.tar.gz: !binary |-
+    MmMzMTQ2N2ZlMTQ4MmVkMTg1MDA0MWUwODYyNmM1ZWFjNDMyODVkMw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MzAxMzljYTA1MWQ4N2I1ZWJkMjhmNjU5MWFjMThkYTZhNTJmMGRiMmM5MjI1
+    NjNjMWY3YjVhODMwNTZjNDlkNzQ1OTcxNjFkZTAyNGI0OGQwNDYwNTQzZTc2
+    NzI5ZWNlNDNiYThlNWU0ODE5NWQ2ZjRlYjRhZjljNDJlNGJmZTQ=
+  data.tar.gz: !binary |-
+    YWYzYjMyZjFlZmIzOTY5NzJmOWQ2OWI4MjZjNzNmZjRhNTdjZmY3YmM2NTgy
+    MTk4NTU0ZGY0MTk5OWZlOTczYzcxMDI5NDRiNWM5MWI0ZDVkOTAxMmU3NWQx
+    N2NjMzNiZTQ5NDc5ODAxMTEzZjI3YjhhY2EyYWE5NzZkNTAzNDc=

data/.gitignore

@@ -0,0 +1,2 @@
+test/tmp/**
+ui/static/**

data/Gemfile

@@ -0,0 +1,5 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+gemspec
+

data/README.md

@@ -0,0 +1,83 @@
+berkshelf-store
+===============
+
+A cookbook store compatible with berkshelf API.
+
+Currently it is a simple webservice :
+* POST /v1/cookbooks/$Name/$Version
+ * cookbook param contains tgz
+* GET /v1/universe
+ * this is berkshelf API
+* GET /v1/cookbooks/$Name/$Version/$Name-$Version.tgz
+ * this is how berkshelf gets the cookbook
+
+Storage is a simple directory tree (easy to backup)
+
+Status
+------
+
+work in progress...
+
+It is my first ruby project, any advise is welcome :)
+
+Why would I need this ?
+-----------------------
+
+If you have private cookbooks or a validation process for public cookboks, you need an internal storage.
+
+If you use chef-solo, knife-solo and/or more than one chef-server, you'll need a central catalog of your cookbooks.
+
+Yes there is berkshelf-api, but it needs a chef server :
+* A litle overkill if you do no plan to really use it.
+* not a uniform service
+ * upload via chef
+ * read via berkshelf
+
+Install
+-------
+
+    gem build berkshelf-store.gemspec
+    gem install berkshelf-store-*.gem
+
+
+Usage
+-----
+
+### Launch the deamon
+
+    Usage: berkshelf-store.rb [options]
+        -D, --datadir DIRECTORY          Data directory (default: ./datadir)
+        -T, --tmpdir DIRECTORY           Tmp directory (default: ./tmpdir)
+        -b, --bind IP                    bind IP (default: 127.0.0.1)
+        -p, --port PORT                  port to listen on (default: 80)
+        -l, --logger TYPE                file, syslog, stderr (default: syslog)
+        -L, --logger-conf TYPE           file: filename, syslog: program.facility, stderr n/a (default: berkshelf-store.daemon)
+
+Example:
+
+    berkshelf-store -D /var/lib/berkshelf-store -T /var/tmp/berkshelf-store --bind 0.0.0.0 -l stderr
+
+### upload some cookbooks
+
+    curl -F cookbook=@/path/to/the/cookbook.tgz http://localhost/v1/cookbooks/cookbookname/cookbookversion
+
+### use it with berkshelf
+
+in the berkfile:
+
+    source "http://localhost/v1"
+
+    cookbook "cookbookname"
+
+TODO:
+-----
+
+by priority
+
+- more Comments and tests
+- cli (knife or beks plugin) for uploading
+- Auth
+- ACL (limit uploads by cookbook/users/groups)
+- UI
+- multi-tenancy ?
+- clusterized/cloudified backend (mongo, S3, whatelse ?)

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rake/testtask'
+require 'net/http'
+
+STATICDIR='ui/static'
+
+desc "Run tests"
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
+task :default => :build
+
+task :build => [ :test, :vendor ] do
+  system "gem build berkshelf-store.gemspec"
+end
+
+directory "#{STATICDIR}"
+task :vendor => [ "#{STATICDIR}/bootstrap", "#{STATICDIR}/jquery/jquery.min.js", "#{STATICDIR}/jquery_file_upload" ] do
+  puts "Vendored"
+end
+
+desc "Get bootstrap"
+directory "#{STATICDIR}/bootstrap" do
+  version = "3.1.1"
+  system "wget https://github.com/twbs/bootstrap/releases/download/v#{version}/bootstrap-#{version}-dist.zip -O #{STATICDIR}/bootstrap.zip"
+  system "cd #{STATICDIR}; unzip bootstrap.zip; mv bootstrap-#{version}-dist bootstrap; rm bootstrap.zip"
+end
+
+desc "Get jquery"
+file "#{STATICDIR}/jquery/jquery.min.js" do
+  version = "1.11.1"
+  system "mkdir #{STATICDIR}/jquery"
+  system "wget http://code.jquery.com/jquery-#{version}.min.js -O #{STATICDIR}/jquery/jquery.min.js"
+end
+
+desc "Get jquery file upload"
+directory "#{STATICDIR}/jquery_file_upload" do
+  version = "9.5.7"
+  system "wget https://github.com/blueimp/jQuery-File-Upload/archive/#{version}.tar.gz -O #{STATICDIR}/jquery_file_upload.tgz"
+  system "cd #{STATICDIR}; tar xvzf jquery_file_upload.tgz; mv jQuery-File-Upload-#{version} jquery_file_upload; rm jquery_file_upload.tgz"
+end
+

data/berkshelf-store.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "berkshelf-store"
+  s.version     = "0.2.0"
+  s.authors     = ["Guillaume Zitta"]
+  s.email       = ["github.guillaume@zitta.fr"]
+  s.homepage    = "https://github.com/gza/berkshelf-store"
+  s.summary     = "A cookbook store based on the berkshelf API"
+  s.description = s.summary
+
+  s.rubyforge_project = "berkshelf-store"
+
+  s.files         = `git ls-files`.split("\n") + Dir.glob("{ui}/**/*")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'syslog-logger'
+  s.add_dependency 'ridley'
+  s.add_dependency 'sinatra', '>=1.4.5'
+  s.add_dependency 'sinatra-contrib', '>=1.4.2'
+
+  s.add_development_dependency 'rake'
+end

data/bin/berkshelf-store

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+$:.push File.expand_path("../../lib", __FILE__)
+
+require 'optparse'
+require 'berkshelf-store'
+
+options = {
+        datadir:"./datadir",
+        tmpdir:"./tmpdir",
+        bind:"127.0.0.1",
+        port:"80",
+        logger_type:"syslog",
+        logger_conf:"berkshelf-store.daemon"
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: berkshelf-store.rb [options]"
+
+  opts.on("-D", "--datadir DIRECTORY", "Data directory (default: #{options[:datadir]})") do |d|
+    options[:datadir] = d
+  end
+
+  opts.on("-T", "--tmpdir DIRECTORY", "Tmp directory (default: #{options[:tmpdir]})") do |t|
+    options[:tmpdir] = t
+  end
+
+  opts.on("-b", "--bind IP", "bind IP (default: #{options[:bind]})") do |ip|
+    options[:bind] = ip
+  end
+
+  opts.on("-p", "--port PORT", "port to listen on (default: #{options[:port]})") do |p|
+    options[:port] = p
+  end
+ 
+  opts.on("-l", "--logger TYPE", "file, syslog, stderr (default: #{options[:logger_type]})") do |l|
+    options[:logger_type] = l
+  end
+  
+  opts.on("-L", "--logger-conf TYPE", "file: filename, syslog: program.facility, stderr n/a (default: #{options[:logger_conf]})") do |lc|
+    options[:logger_conf] = lc
+  end
+end.parse!
+
+#The only way I found to pass options to configure
+ENV['LOGGER_TYPE'] ||= options.delete(:logger_type)
+ENV['LOGGER_CONF'] ||= options.delete(:logger_conf)
+
+#remaining options will be available as settings
+BerkshelfStore::Webservice.run!(options)

data/lib/berkshelf-store/backends/filesystem.rb

@@ -0,0 +1,138 @@
+require 'digest'
+require 'json'
+require 'fileutils'
+require 'ridley'
+
+module BerkshelfStore::Backends
+  class Filesystem
+
+    @error = ''
+  
+    def initialize(path, tmp)
+      @path = path
+      @tmp = tmp
+    end
+  
+    def check_filename(filename)
+      #do minimal checks
+      true
+    end
+  
+    def store(content, name, version)
+      data = {}
+
+      digest = Digest::SHA256.hexdigest(content)
+      tmp_dir = "#{@tmp}/#{digest}"
+      
+      FileUtils.mkdir_p "#{tmp_dir}/cookbook"
+
+      #extract cookbook
+      if write_tmp_file("#{tmp_dir}/cookbook.tgz", content)
+        cmd = "tar --gzip --extract --file=\"#{tmp_dir}/cookbook.tgz\" -C \"#{tmp_dir}/cookbook\""
+        %x{#{cmd}}
+  
+        if $?.exitstatus != 0
+          return {"fail" => "Failed to extract metadata.rb from tarball"}
+        end
+      else
+        return {"fail" => "Unable to write cookbook #{tmp_dir}/cookbook.tgz"}
+      end
+  
+      #locate check cookbook
+      search_root = Dir["#{tmp_dir}/cookbook/*/metadata.rb"]
+      if search_root.size != 1
+        return {"fail" => "tgz don't contains one and only on */metadata.rb"}
+      end
+      cookbook_dir = File.dirname(search_root[0])
+        
+      #Extract information
+      begin
+        cookbook = Ridley::Chef::Cookbook.from_path(cookbook_dir)
+        data = cookbook_data(cookbook)
+      rescue Exception => e
+        return {"fail" => "Information extraction failed #{e}"}
+      end
+
+      begin
+        data_dir = "#{@path}/#{name}/#{version}"
+        FileUtils.mkdir_p "#{data_dir}" 
+      rescue SystemCallError => e
+        return {"fail" => "#{data_dir} creation failed #{e}"}
+      end
+
+      begin
+        json_file = File.open("#{data_dir}/data.json", "w")
+        json_file.write(data.to_json)
+        json_file.close
+      rescue Exception => e
+        return {"fail" => "#{data_dir}/data.json creation failed #{e}"}
+      end
+  
+      begin
+        File.rename("#{tmp_dir}/cookbook.tgz", "#{data_dir}/#{name}-#{version}.tgz")
+      rescue Exception => e
+        return {"fail" => "tarball store failed #{e}"}
+      end
+
+      return data
+    end
+  
+    def cookbook_data(cookbook)
+      platforms = cookbook.metadata.platforms || Hash.new
+      dependencies = cookbook.metadata.dependencies || Hash.new
+  
+      name = cookbook.cookbook_name.to_s
+      version = cookbook.version.to_s
+  
+      path = "/#{name}/#{version}/#{name}-#{version}.tgz"
+  
+      retval = {
+        "name" => name,
+        "version" => version,
+        "data" => {
+          "endpoint_priority" => 0,
+          "platforms" => platforms,
+          "dependencies" => dependencies,
+          "location_type" => 'uri',
+          "location_path" => path
+        }
+      }
+      return retval
+    end
+  
+    def write_tmp_file(name, content)
+      begin
+        tarfile = File.open("#{name}", "w")
+        tarfile.write(content)
+      rescue IOError => e
+        @error="Failed to write temp file #{name}"
+        return false
+      ensure
+        tarfile.close unless tarfile == nil
+      end
+    end
+
+    def last_error
+      @error
+    end
+
+    def get_json(name, version)
+      File.open("#{@path}/#{name}/#{version}/data.json", "r").read
+    end
+
+    def get_tarball(name, version)
+      File.open("#{@path}/#{name}/#{version}/#{name}-#{version}.tgz").read
+    end
+
+    def get_catalog(prefix)
+      retval = {}
+      Dir["#{@path}/*/*/data.json"].each do |json_file|
+         data = JSON.parse(File.read("#{json_file}"))
+	 data['data']['location_path'] = "#{prefix}#{data['data']['location_path']}"
+	 retval[data['name']] ||= Hash.new
+	 retval[data['name']][data['version']] = data['data']
+      end
+      retval
+    end
+  end
+end

data/lib/berkshelf-store/backends.rb

@@ -0,0 +1,5 @@
+module BerkshelfStore
+  module Backends
+    autoload :Filesystem, 'berkshelf-store/backends/filesystem'
+  end
+end

data/lib/berkshelf-store/webservice.rb

@@ -0,0 +1,100 @@
+require 'sinatra/base'
+require 'sinatra/json'
+require 'syslog-logger'
+require 'logger'
+
+#require 'berkshelf-store'
+::Logger.class_eval { alias :write :'<<' }
+::Logger::Syslog.class_eval { alias :write :'<<' }
+
+module BerkshelfStore
+  class Webservice < Sinatra::Base
+    helpers Sinatra::JSON
+
+    helpers do
+      def logger
+        settings.logger
+      end
+    end
+
+    configure do
+      logger_type = ENV['LOGGER_TYPE'].to_s
+      logger_conf = ENV['LOGGER_CONF'].to_s
+      if logger_type == "file"
+        logger = Logger.new(File.open("#{logger_conf}", 'a'))
+      elsif logger_type == "stderr"
+        logger = Logger.new(STDERR)
+      elsif logger_type == "syslog"
+        programname = logger_conf.split(".")[0]
+        facility = eval("Syslog::LOG_#{logger_conf.to_s.split(".")[1].upcase}")
+        logger = Logger::Syslog.new(programname, facility)
+      end
+      use ::Rack::CommonLogger, logger
+      set :logger, logger
+
+      #static files (UI) stuff
+      #et :public_folder, BerkshelfStore::ROOT + '/www/static'
+
+    end
+    set :prefix, "/"
+    set :public_folder, BerkshelfStore::ROOT + '/ui/static'
+    set :views, BerkshelfStore::ROOT + '/ui/views'
+
+
+    get "/ping" do
+      logger.info 'ping'
+      json({'info'    => 'berkshelf-store',
+            'version' => 'it would be nice to show it :)',
+            'status'  => 'seems to work :)'})
+    end
+
+    get "/v1/universe" do
+      cookbooks_url_prefix = "#{request.base_url}/v1/cookbooks"
+      storage = BerkshelfStore::Backends::Filesystem.new(settings.datadir, settings.tmpdir)
+      json(storage.get_catalog(cookbooks_url_prefix))
+    end
+
+    get "/v1/cookbooks/:name/:version/:filename" do
+      if params[:filename] == "#{params[:name]}-#{params[:version]}.tgz"
+        storage = BerkshelfStore::Backends::Filesystem.new(settings.datadir, settings.tmpdir)
+        storage.get_tarball(params[:name],params[:version])
+      else
+        halt 400, json({'fail' => 'cookbook name should be name-version.tgz'})
+      end
+    end
+
+    post "/v1/cookbooks/:name/:version" do
+      if params.key?("cookbook") && params.key?("name") && params.key?("version")
+        storage = BerkshelfStore::Backends::Filesystem.new(settings.datadir, settings.tmpdir)
+        cookbook_data = storage.store(params["cookbook"][:tempfile].read, params[:name], params[:version])
+        if cookbook_data.key?('name')
+          json cookbook_data
+        else
+          halt 500, json(cookbook_data)
+        end
+      else
+        halt 400, json({'fail' => 'Wrong parameters'})
+      end
+    end
+
+    get "/" do
+      redirect "/index.html"
+    end
+
+    get "/:name.html" do
+      @site_prefix="#{request.base_url}"
+      @ws_prefix="/v1"
+      @active="#{params[:name]}" 
+      if params[:name] == 'index'
+        erb :catalog
+      elsif params[:name] == 'upload'
+        erb :upload
+      elsif params[:name] == 'doc'
+        erb :doc
+      else
+        halt 404, "<h1>page #{params[:name]}.html not found</h1>"
+      end
+    end
+
+  end
+end

data/lib/berkshelf-store.rb

@@ -0,0 +1,5 @@
+module BerkshelfStore
+  ROOT = File.expand_path("../..", __FILE__)
+  autoload :Backends, 'berkshelf-store/backends'
+  autoload :Webservice, 'berkshelf-store/webservice'
+end

data/test/data/arbo/cookbooks/apache2/1.10.4/data.json

@@ -0,0 +1 @@
+{"name":"apache2","version":"1.10.4","data":{"endpoint_priority":0,"platforms":{"amazon":">= 0.0.0","arch":">= 0.0.0","centos":">= 0.0.0","debian":">= 0.0.0","fedora":">= 0.0.0","freebsd":">= 0.0.0","redhat":">= 0.0.0","scientific":">= 0.0.0","ubuntu":">= 0.0.0"},"dependencies":{"iptables":">= 0.0.0","logrotate":">= 0.0.0","pacman":">= 0.0.0"},"location_type":"uri","location_path":"/apache2/1.10.4/apache2-1.10.4.tgz"}}

data/test/data/arbo/cookbooks/couchbase/1.1.0/data.json

@@ -0,0 +1 @@
+{"name":"couchbase","version":"1.1.0","data":{"endpoint_priority":0,"platforms":{"debian":">= 0.0.0","ubuntu":">= 0.0.0","centos":">= 0.0.0","redhat":">= 0.0.0","oracle":">= 0.0.0","amazon":">= 0.0.0","scientific":">= 0.0.0","windows":">= 0.0.0"},"dependencies":{"apt":">= 0.0.0","openssl":">= 0.0.0","windows":">= 0.0.0","yum":">= 0.0.0"},"location_type":"uri","location_path":"/couchbase/1.1.0/couchbase-1.1.0.tgz"}}

data/test/data/arbo/cookbooks/couchbase/1.2.0/data.json

@@ -0,0 +1 @@
+{"name":"couchbase","version":"1.2.0","data":{"endpoint_priority":0,"platforms":{"debian":">= 0.0.0","ubuntu":">= 0.0.0","centos":">= 0.0.0","redhat":">= 0.0.0","oracle":">= 0.0.0","amazon":">= 0.0.0","scientific":">= 0.0.0","windows":">= 0.0.0"},"dependencies":{"apt":">= 0.0.0","openssl":">= 0.0.0","windows":">= 0.0.0","yum":">= 0.0.0"},"location_type":"uri","location_path":"/couchbase/1.2.0/couchbase-1.2.0.tgz"}}

data/test/data/catalog.json

@@ -0,0 +1,69 @@
+{
+    "apache2": {
+        "1.10.4": {
+            "dependencies": {
+                "iptables": ">= 0.0.0",
+                "logrotate": ">= 0.0.0",
+                "pacman": ">= 0.0.0"
+            },
+            "endpoint_priority": 0,
+            "location_path": "http://localhost/apache2/1.10.4/apache2-1.10.4.tgz",
+            "location_type": "uri",
+            "platforms": {
+                "amazon": ">= 0.0.0",
+                "arch": ">= 0.0.0",
+                "centos": ">= 0.0.0",
+                "debian": ">= 0.0.0",
+                "fedora": ">= 0.0.0",
+                "freebsd": ">= 0.0.0",
+                "redhat": ">= 0.0.0",
+                "scientific": ">= 0.0.0",
+                "ubuntu": ">= 0.0.0"
+            }
+        }
+    },
+    "couchbase": {
+        "1.1.0": {
+            "dependencies": {
+                "apt": ">= 0.0.0",
+                "openssl": ">= 0.0.0",
+                "windows": ">= 0.0.0",
+                "yum": ">= 0.0.0"
+            },
+            "endpoint_priority": 0,
+            "location_path": "http://localhost/couchbase/1.1.0/couchbase-1.1.0.tgz",
+            "location_type": "uri",
+            "platforms": {
+                "amazon": ">= 0.0.0",
+                "centos": ">= 0.0.0",
+                "debian": ">= 0.0.0",
+                "oracle": ">= 0.0.0",
+                "redhat": ">= 0.0.0",
+                "scientific": ">= 0.0.0",
+                "ubuntu": ">= 0.0.0",
+                "windows": ">= 0.0.0"
+            }
+        },
+        "1.2.0": {
+            "dependencies": {
+                "apt": ">= 0.0.0",
+                "openssl": ">= 0.0.0",
+                "windows": ">= 0.0.0",
+                "yum": ">= 0.0.0"
+            },
+            "endpoint_priority": 0,
+            "location_path": "http://localhost/couchbase/1.2.0/couchbase-1.2.0.tgz",
+            "location_type": "uri",
+            "platforms": {
+                "amazon": ">= 0.0.0",
+                "centos": ">= 0.0.0",
+                "debian": ">= 0.0.0",
+                "oracle": ">= 0.0.0",
+                "redhat": ">= 0.0.0",
+                "scientific": ">= 0.0.0",
+                "ubuntu": ">= 0.0.0",
+                "windows": ">= 0.0.0"
+            }
+        }
+    }
+}

data/test/test_berkshelf-store_backends_filesystem.rb

@@ -0,0 +1,76 @@
+require 'json'
+require 'test/unit'
+require 'berkshelf-store'
+
+class BerkshelfRepoBackendsFilesystemTest < Test::Unit::TestCase
+
+  def setup
+    @test_dir = File.dirname(__FILE__)
+    @tarballs = "#{@test_dir}/data/tarballs"
+    @dataarbo = "#{@test_dir}/data/arbo"
+    @tmp="#{@test_dir}/tmp/tmp"
+    @path="#{@test_dir}/tmp/path"
+
+    #test_cases
+    @test_case = Hash.new
+    @test_case[:couchbase_1_2_0] = Hash.new
+    @test_case[:couchbase_1_2_0][:name] = 'couchbase'
+    @test_case[:couchbase_1_2_0][:version] = '1.2.0'
+    @test_case[:couchbase_1_2_0][:content] = File.read("#{@tarballs}/couchbase-v1.2.0.tar.gz")
+    @test_case[:couchbase_1_2_0][:json] = File.read("#{@dataarbo}/cookbooks/couchbase/1.2.0/data.json")
+  end
+
+  def clean
+    FileUtils.rm_rf(@tmp)
+    FileUtils.mkdir_p(@tmp)
+    FileUtils.rm_rf(@path)
+    FileUtils.mkdir_p(@path)
+  end
+
+  def test_store
+    clean()
+    
+    @test_case.values.each do |cookbook|
+      repo=BerkshelfStore::Backends::Filesystem.new(@path,@tmp)
+
+      cbdir = "#{@path}/#{cookbook[:name]}/#{cookbook[:version]}"
+      #Must not exists before
+      assert(! File.exists?(cbdir))
+
+      result_store = repo.store(cookbook[:content], cookbook[:name], cookbook[:version])
+
+      assert(File.exists?(cbdir))
+      assert(File.exists?("#{cbdir}/#{cookbook[:name]}-#{cookbook[:version]}.tgz"))
+      assert(File.exists?("#{cbdir}/data.json"))
+      
+      assert( result_store )
+
+      generated_data = JSON.parse(File.read("#{cbdir}/data.json"))
+      control_data = JSON.parse(cookbook[:json])
+      assert_equal(control_data, generated_data)
+    end 
+  end
+
+  def test_store_bad_tgz
+    clean()
+    repo=BerkshelfStore::Backends::Filesystem.new(@path,@tmp)
+    result_store = repo.store("this is not tgz data, hi hi", "toto", "0.0.0")
+    assert( result_store.key?('fail') )
+  end
+
+  def test_store_not_cookbook_tgz
+    clean()
+    repo=BerkshelfStore::Backends::Filesystem.new(@path,@tmp)
+    result_store = repo.store(File.read("#{@tarballs}/not_a_cookbook.tgz"), "toto", "0.0.0")
+    assert( result_store.key?('fail') )
+  end
+
+  def test_get_catalog
+    clean()
+
+    repo=BerkshelfStore::Backends::Filesystem.new("#{@dataarbo}/cookbooks", @tmp)
+    generated_data = repo.get_catalog("http://localhost")
+    control_data = JSON.parse(File.read("#{@test_dir}/data/catalog.json"))
+    assert_equal(control_data, generated_data)
+  end
+end