chrome/browser/mac/keystone_glue_unittest.mm

   1 // Copyright (c) 2011 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 #import <Foundation/Foundation.h>
   6 #import <objc/objc-class.h>
   7
   8 #import "chrome/browser/mac/keystone_glue.h"
   9 #import "chrome/browser/mac/keystone_registration.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11 #include "testing/platform_test.h"
  12
  13 namespace ksr = keystone_registration;
  14
  15
  16 @interface FakeKeystoneRegistration : KSRegistration
  17 @end
  18
  19
  20 // This unit test implements FakeKeystoneRegistration as a KSRegistration
  21 // subclass. It won't be linked against KSRegistration, so provide a stub
  22 // KSRegistration class on which to base FakeKeystoneRegistration.
  23 @implementation KSRegistration
  24
  25 + (id)registrationWithProductID:(NSString*)productID {
  26   return nil;
  27 }
  28
  29 - (BOOL)registerWithParameters:(NSDictionary*)args {
  30   return NO;
  31 }
  32
  33 - (BOOL)promoteWithParameters:(NSDictionary*)args
  34                 authorization:(AuthorizationRef)authorization {
  35   return NO;
  36 }
  37
  38 - (BOOL)setActive {
  39   return NO;
  40 }
  41
  42 - (BOOL)setActiveWithReportingAttributes:(NSArray*)reportingAttributes
  43                                    error:(NSError**)error {
  44   return NO;
  45 }
  46
  47 - (void)checkForUpdateWasUserInitiated:(BOOL)userInitiated {
  48 }
  49
  50 - (void)startUpdate {
  51 }
  52
  53 - (ksr::KSRegistrationTicketType)ticketType {
  54   return ksr::kKSRegistrationDontKnowWhatKindOfTicket;
  55 }
  56
  57 @end
  58
  59
  60 @implementation FakeKeystoneRegistration
  61
  62 // Send the notifications that a real KeystoneGlue object would send.
  63
  64 - (void)checkForUpdateWasUserInitiated:(BOOL)userInitiated {
  65   NSNumber* yesNumber = [NSNumber numberWithBool:YES];
  66   NSString* statusKey = @"Status";
  67   NSDictionary* dictionary = [NSDictionary dictionaryWithObject:yesNumber
  68                                                          forKey:statusKey];
  69   NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
  70   [center postNotificationName:ksr::KSRegistrationCheckForUpdateNotification
  71                         object:nil
  72                       userInfo:dictionary];
  73 }
  74
  75 - (void)startUpdate {
  76   NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
  77   [center postNotificationName:ksr::KSRegistrationStartUpdateNotification
  78                         object:nil];
  79 }
  80
  81 @end
  82
  83
  84 @interface FakeKeystoneGlue : KeystoneGlue {
  85  @public
  86   BOOL upToDate_;
  87   NSString *latestVersion_;
  88   BOOL successful_;
  89   int installs_;
  90 }
  91
  92 - (void)fakeAboutWindowCallback:(NSNotification*)notification;
  93 @end
  94
  95
  96 @implementation FakeKeystoneGlue
  97
  98 - (id)init {
  99   if ((self = [super init])) {
 100     // some lies
 101     upToDate_ = YES;
 102     latestVersion_ = @"foo bar";
 103     successful_ = YES;
 104     installs_ = 1010101010;
 105
 106     // Set up an observer that takes the notification that the About window
 107     // listens for.
 108     NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
 109     [center addObserver:self
 110                selector:@selector(fakeAboutWindowCallback:)
 111                    name:kAutoupdateStatusNotification
 112                  object:nil];
 113   }
 114   return self;
 115 }
 116
 117 - (void)dealloc {
 118   [[NSNotificationCenter defaultCenter] removeObserver:self];
 119   [super dealloc];
 120 }
 121
 122 // For mocking
 123 - (NSDictionary*)infoDictionary {
 124   NSDictionary* dict = [NSDictionary dictionaryWithObjectsAndKeys:
 125                                      @"http://foo.bar", @"KSUpdateURL",
 126                                      @"com.google.whatever", @"KSProductID",
 127                                      @"0.0.0.1", @"KSVersion",
 128                                      nil];
 129   return dict;
 130 }
 131
 132 // For mocking
 133 - (BOOL)loadKeystoneRegistration {
 134   return YES;
 135 }
 136
 137 // Confirms certain things are happy
 138 - (BOOL)dictReadCorrectly {
 139   return ([url_ isEqual:@"http://foo.bar"] &&
 140           [productID_ isEqual:@"com.google.whatever"] &&
 141           [version_ isEqual:@"0.0.0.1"]);
 142 }
 143
 144 // Confirms certain things are happy
 145 - (BOOL)hasATimer {
 146   return timer_ ? YES : NO;
 147 }
 148
 149 - (void)addFakeRegistration {
 150   registration_ = [[FakeKeystoneRegistration alloc] init];
 151 }
 152
 153 - (void)fakeAboutWindowCallback:(NSNotification*)notification {
 154   NSDictionary* dictionary = [notification userInfo];
 155   AutoupdateStatus status = static_cast<AutoupdateStatus>(
 156       [[dictionary objectForKey:kAutoupdateStatusStatus] intValue]);
 157
 158   if (status == kAutoupdateAvailable) {
 159     upToDate_ = NO;
 160     latestVersion_ = [dictionary objectForKey:kAutoupdateStatusVersion];
 161   } else if (status == kAutoupdateInstallFailed) {
 162     successful_ = NO;
 163     installs_ = 0;
 164   }
 165 }
 166
 167 // Confirm we look like callbacks with nil NSNotifications
 168 - (BOOL)confirmCallbacks {
 169   return (!upToDate_ &&
 170           (latestVersion_ == nil) &&
 171           !successful_ &&
 172           (installs_ == 0));
 173 }
 174
 175 @end
 176
 177
 178 namespace {
 179
 180 class KeystoneGlueTest : public PlatformTest {
 181 };
 182
 183 // DISABLED because the mocking isn't currently working.
 184 TEST_F(KeystoneGlueTest, DISABLED_BasicGlobalCreate) {
 185   // Allow creation of a KeystoneGlue by mocking out a few calls
 186   SEL ids = @selector(infoDictionary);
 187   IMP oldInfoImp_ = [[KeystoneGlue class] instanceMethodForSelector:ids];
 188   IMP newInfoImp_ = [[FakeKeystoneGlue class] instanceMethodForSelector:ids];
 189   Method infoMethod_ = class_getInstanceMethod([KeystoneGlue class], ids);
 190   method_setImplementation(infoMethod_, newInfoImp_);
 191
 192   SEL lks = @selector(loadKeystoneRegistration);
 193   IMP oldLoadImp_ = [[KeystoneGlue class] instanceMethodForSelector:lks];
 194   IMP newLoadImp_ = [[FakeKeystoneGlue class] instanceMethodForSelector:lks];
 195   Method loadMethod_ = class_getInstanceMethod([KeystoneGlue class], lks);
 196   method_setImplementation(loadMethod_, newLoadImp_);
 197
 198   KeystoneGlue *glue = [KeystoneGlue defaultKeystoneGlue];
 199   ASSERT_TRUE(glue);
 200
 201   // Fix back up the class to the way we found it.
 202   method_setImplementation(infoMethod_, oldInfoImp_);
 203   method_setImplementation(loadMethod_, oldLoadImp_);
 204 }
 205
 206 // DISABLED because the mocking isn't currently working.
 207 TEST_F(KeystoneGlueTest, DISABLED_BasicUse) {
 208   FakeKeystoneGlue* glue = [[[FakeKeystoneGlue alloc] init] autorelease];
 209   [glue loadParameters];
 210   ASSERT_TRUE([glue dictReadCorrectly]);
 211
 212   // Likely returns NO in the unit test, but call it anyway to make
 213   // sure it doesn't crash.
 214   [glue loadKeystoneRegistration];
 215
 216   // Confirm we start up an active timer
 217   [glue registerWithKeystone];
 218   ASSERT_TRUE([glue hasATimer]);
 219   [glue stopTimer];
 220
 221   // Brief exercise of callbacks
 222   [glue addFakeRegistration];
 223   [glue checkForUpdate];
 224   [glue installUpdate];
 225   ASSERT_TRUE([glue confirmCallbacks]);
 226 }
 227
 228 }  // namespace