src/mojo/shell/dynamic_application_loader_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/files/scoped_temp_dir.h"
   6 #include "mojo/shell/context.h"
   7 #include "mojo/shell/dynamic_application_loader.h"
   8 #include "mojo/shell/dynamic_service_runner.h"
   9 #include "net/base/filename_util.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace mojo {
  13 namespace shell {
  14
  15 namespace {
  16
  17 struct TestState {
  18   TestState()
  19       : runner_was_created(false),
  20         runner_was_started(false),
  21         runner_was_destroyed(false) {}
  22
  23   bool runner_was_created;
  24   bool runner_was_started;
  25   bool runner_was_destroyed;
  26 };
  27
  28 class TestDynamicServiceRunner : public DynamicServiceRunner {
  29  public:
  30   explicit TestDynamicServiceRunner(TestState* state) : state_(state) {
  31     state_->runner_was_created = true;
  32   }
  33   virtual ~TestDynamicServiceRunner() {
  34     state_->runner_was_destroyed = true;
  35     base::MessageLoop::current()->Quit();
  36   }
  37   virtual void Start(const base::FilePath& app_path,
  38                      ScopedMessagePipeHandle service_handle,
  39                      const base::Closure& app_completed_callback) OVERRIDE {
  40     state_->runner_was_started = true;
  41   }
  42
  43  private:
  44   TestState* state_;
  45 };
  46
  47 class TestDynamicServiceRunnerFactory : public DynamicServiceRunnerFactory {
  48  public:
  49   explicit TestDynamicServiceRunnerFactory(TestState* state) : state_(state) {}
  50   virtual ~TestDynamicServiceRunnerFactory() {}
  51   virtual scoped_ptr<DynamicServiceRunner> Create(Context* context) OVERRIDE {
  52     return scoped_ptr<DynamicServiceRunner>(
  53         new TestDynamicServiceRunner(state_));
  54   }
  55
  56  private:
  57   TestState* state_;
  58 };
  59
  60 }  // namespace
  61
  62 class DynamicApplicationLoaderTest : public testing::Test {
  63  public:
  64   DynamicApplicationLoaderTest() {}
  65   virtual ~DynamicApplicationLoaderTest() {}
  66   virtual void SetUp() OVERRIDE {
  67     context_.Init();
  68     scoped_ptr<DynamicServiceRunnerFactory> factory(
  69         new TestDynamicServiceRunnerFactory(&state_));
  70     loader_.reset(new DynamicApplicationLoader(&context_, factory.Pass()));
  71   }
  72
  73  protected:
  74   Context context_;
  75   base::MessageLoop loop_;
  76   scoped_ptr<DynamicApplicationLoader> loader_;
  77   TestState state_;
  78 };
  79
  80 TEST_F(DynamicApplicationLoaderTest, DoesNotExist) {
  81   base::ScopedTempDir temp_dir;
  82   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  83   base::FilePath nonexistent_file(FILE_PATH_LITERAL("nonexistent.txt"));
  84   GURL url(net::FilePathToFileURL(temp_dir.path().Append(nonexistent_file)));
  85   MessagePipe pipe;
  86   scoped_refptr<ApplicationLoader::SimpleLoadCallbacks> callbacks(
  87       new ApplicationLoader::SimpleLoadCallbacks(pipe.handle0.Pass()));
  88   loader_->Load(context_.application_manager(), url, callbacks);
  89   EXPECT_FALSE(state_.runner_was_created);
  90   EXPECT_FALSE(state_.runner_was_started);
  91   EXPECT_FALSE(state_.runner_was_destroyed);
  92 }
  93
  94 }  // namespace shell
  95 }  // namespace mojo