File XWikiMockitoTest.java

Branches:

Statements:

213

Methods:

Classes:

LOC:

511

NCLOC:

364

Total complexity:

Complexity density:

0.08

Statements/Method:

15.21

Methods/Class:

Average method complexity:

1.14

Classes

Class	Line #	Total Statements	% Filtered	Complexity	Uncovered Elements	TOTAL Coverage	Actions
XWikiMockitoTest	89	213	0%	16	3	0.98701398.7%

Class XWikiMockitoTest

Class XWikiMockitoTest	Line # 89	Total Statements 213	% Filtered 0%	Complexity 16	Uncovered Elements 3	TOTAL Coverage 0.98701398.7%
setUp() : void setUp() : void	111111	29.029	0.00%	1.01	0.00	1.0 1.0100%
copyDocumentPreservesAttachmentsVersion() : void copyDocumentPreservesAttachmentsVersion() : void	155155	11.011	0.00%	1.01	0.00	1.0 1.0100%
rollbackFiresEvents() : void rollbackFiresEvents() : void	180180	18.018	0.00%	1.01	0.00	1.0 1.0100%
rollbackDoesNotSaveUnchangedAttachment() : void rollbackDoesNotSaveUnchangedAttachment() : void	215215	32.032	0.00%	1.01	0.00	1.0 1.0100%
deleteAllDocumentsAndWithoutSendingToTrash() : void deleteAllDocumentsAndWithoutSendingToTrash() : void	262262	13.013	0.00%	1.01	0.00	1.0 1.0100%
matches(XWikiDocument) : boolean matches(XWikiDocument) : boolean	308308	1.01	0.00%	1.01	0.00	1.0 1.0100%
deleteDocument() : void deleteDocument() : void	292292	11.011	0.00%	1.01	0.00	1.0 1.0100%
getPlainUserName() : void getPlainUserName() : void	325325	15.015	0.00%	1.01	0.00	1.0 1.0100%
getURLWithDotsAndBackslashInSpaceName() : void getURLWithDotsAndBackslashInSpaceName() : void	348348	7.07	0.00%	1.01	0.00	1.0 1.0100%
getURLWithLocale() : void getURLWithLocale() : void	365365	9.09	0.00%	1.01	0.00	1.0 1.0100%
getEntityURLWithDefaultAction() : void getEntityURLWithDefaultAction() : void	384384	14.014	0.00%	1.01	0.00	1.0 1.0100%
answer(InvocationOnMock) : String answer(InvocationOnMock) : String	423423	1.01	0.00%	1.01	0.00	1.0 1.0100%
answer(InvocationOnMock) : String answer(InvocationOnMock) : String	466466	5.05	0.00%	3.03	3.03	0.6666667 0.666666766.7%
getSpacePreference() : void getSpacePreference() : void	415415	47.047	0.00%	1.01	0.00	1.0 1.0100%

Contributing tests

This file is covered by 10 tests. .

Contributing tests

Test contribution	Test	Result
0.24675325	com.xpn.xwiki.XWikiMockitoTest.getSpacePreferencecom.xpn.xwiki.XWikiMockitoTest.getSpacePreference	1PASS
0.14285715	com.xpn.xwiki.XWikiMockitoTest.rollbackDoesNotSaveUnchangedAttachmentcom.xpn.xwiki.XWikiMockitoTest.rollbackDoesNotSaveUnchangedAttachment	1PASS
0.08225108	com.xpn.xwiki.XWikiMockitoTest.rollbackFiresEventscom.xpn.xwiki.XWikiMockitoTest.rollbackFiresEvents	1PASS
0.06926407	com.xpn.xwiki.XWikiMockitoTest.getPlainUserNamecom.xpn.xwiki.XWikiMockitoTest.getPlainUserName	1PASS
0.064935066	com.xpn.xwiki.XWikiMockitoTest.getEntityURLWithDefaultActioncom.xpn.xwiki.XWikiMockitoTest.getEntityURLWithDefaultAction	1PASS
0.060606062	com.xpn.xwiki.XWikiMockitoTest.deleteAllDocumentsAndWithoutSendingToTrashcom.xpn.xwiki.XWikiMockitoTest.deleteAllDocumentsAndWithoutSendingToTrash	1PASS
0.060606062	com.xpn.xwiki.XWikiMockitoTest.deleteDocumentcom.xpn.xwiki.XWikiMockitoTest.deleteDocument	1PASS
0.051948052	com.xpn.xwiki.XWikiMockitoTest.copyDocumentPreservesAttachmentsVersioncom.xpn.xwiki.XWikiMockitoTest.copyDocumentPreservesAttachmentsVersion	1PASS
0.043290045	com.xpn.xwiki.XWikiMockitoTest.getURLWithLocalecom.xpn.xwiki.XWikiMockitoTest.getURLWithLocale	1PASS
0.034632035	com.xpn.xwiki.XWikiMockitoTest.getURLWithDotsAndBackslashInSpaceNamecom.xpn.xwiki.XWikiMockitoTest.getURLWithDotsAndBackslashInSpaceName	1PASS

Source view

* See the NOTICE file distributed with this work for additional

* information regarding copyright ownership.

* This is free software; you can redistribute it and/or modify it

* under the terms of the GNU Lesser General Public License as

* published by the Free Software Foundation; either version 2.1 of

* the License, or (at your option) any later version.

* This software is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

* You should have received a copy of the GNU Lesser General Public

* License along with this software; if not, write to the Free

* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

* 02110-1301 USA, or see the FSF site: http://www.fsf.org.

package com.xpn.xwiki;

import java.sql.Timestamp;

import java.util.Arrays;

import java.util.Date;

import java.util.HashMap;

import java.util.Locale;

import java.util.Map;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Rule;

import org.junit.Test;

import org.mockito.ArgumentMatcher;

import org.mockito.invocation.InvocationOnMock;

import org.mockito.stubbing.Answer;

import org.xwiki.bridge.event.DocumentDeletedEvent;

import org.xwiki.bridge.event.DocumentDeletingEvent;

import org.xwiki.bridge.event.DocumentRolledBackEvent;

import org.xwiki.bridge.event.DocumentRollingBackEvent;

import org.xwiki.bridge.event.DocumentUpdatedEvent;

import org.xwiki.bridge.event.DocumentUpdatingEvent;

import org.xwiki.configuration.ConfigurationSource;

import org.xwiki.environment.Environment;

import org.xwiki.localization.ContextualLocalizationManager;

import org.xwiki.model.reference.AttachmentReference;

import org.xwiki.model.reference.AttachmentReferenceResolver;

import org.xwiki.model.reference.DocumentReference;

import org.xwiki.model.reference.DocumentReferenceResolver;

import org.xwiki.model.reference.EntityReference;

import org.xwiki.model.reference.EntityReferenceProvider;

import org.xwiki.model.reference.EntityReferenceResolver;

import org.xwiki.model.reference.EntityReferenceSerializer;

import org.xwiki.model.reference.ObjectReferenceResolver;

import org.xwiki.model.reference.SpaceReference;

import org.xwiki.model.reference.WikiReference;

import org.xwiki.observation.ObservationManager;

import org.xwiki.rendering.syntax.SyntaxFactory;

import org.xwiki.resource.ResourceReferenceManager;

import org.xwiki.test.mockito.MockitoComponentManagerRule;

import com.xpn.xwiki.doc.XWikiAttachment;

import com.xpn.xwiki.doc.XWikiDocument;

import com.xpn.xwiki.internal.XWikiCfgConfigurationSource;

import com.xpn.xwiki.objects.BaseObject;

import com.xpn.xwiki.store.AttachmentRecycleBinStore;

import com.xpn.xwiki.store.XWikiRecycleBinStoreInterface;

import com.xpn.xwiki.store.XWikiStoreInterface;

import com.xpn.xwiki.store.XWikiVersioningStoreInterface;

import com.xpn.xwiki.web.Utils;

import com.xpn.xwiki.web.XWikiURLFactory;

import static org.junit.Assert.assertEquals;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.ArgumentMatchers.anyString;

import static org.mockito.ArgumentMatchers.argThat;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.ArgumentMatchers.same;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.verifyNoMoreInteractions;

import static org.mockito.Mockito.when;

/**

* Unit tests for {@link XWiki}.

* @version $Id: 76c2e067dcd37f36585cdd3a3db70fbc28390f68 $

public class XWikiMockitoTest

{

/**

* A component manager that allows us to register mock components.

@Rule

public MockitoComponentManagerRule mocker = new MockitoComponentManagerRule();

/**

* The object being tested.

private XWiki xwiki;

/**

* A mock {@link XWikiContext};

104

105

private XWikiContext context = new XWikiContext();

106

107

private ConfigurationSource xwikiCfgConfigurationSource;

108

109

private XWikiStoreInterface storeMock;

110

111

@Before

112

public void setUp() throws Exception

113

{

114

this.mocker.registerMockComponent(EntityReferenceSerializer.TYPE_STRING);

115

this.mocker.registerMockComponent(EntityReferenceSerializer.TYPE_STRING, "local");

116

this.mocker.registerMockComponent(EntityReferenceSerializer.TYPE_STRING, "compact");

117

this.mocker.registerMockComponent(EntityReferenceSerializer.TYPE_STRING, "compactwiki");

118

this.mocker.registerMockComponent(EntityReferenceSerializer.TYPE_STRING, "uid");

119

this.mocker.registerMockComponent(EntityReferenceSerializer.TYPE_STRING, "local/uid");

120

this.mocker.registerMockComponent(EntityReferenceResolver.TYPE_STRING, "relative");

121

this.mocker.registerMockComponent(EntityReferenceResolver.TYPE_STRING, "currentmixed");

122

this.mocker.registerMockComponent(EntityReferenceResolver.TYPE_STRING, "xclass");

123

this.mocker.registerMockComponent(DocumentReferenceResolver.TYPE_REFERENCE, "current");

124

this.mocker.registerMockComponent(DocumentReferenceResolver.TYPE_REFERENCE, "explicit");

125

this.mocker.registerMockComponent(DocumentReferenceResolver.TYPE_STRING, "current");

126

this.mocker.registerMockComponent(DocumentReferenceResolver.TYPE_STRING, "explicit");

127

this.mocker.registerMockComponent(DocumentReferenceResolver.TYPE_STRING, "currentmixed");

128

this.mocker.registerMockComponent(ObjectReferenceResolver.TYPE_REFERENCE, "current");

129

this.mocker.registerMockComponent(EntityReferenceProvider.class);

130

this.mocker.registerMockComponent(SyntaxFactory.class);

131

this.mocker.registerMockComponent(ResourceReferenceManager.class);

132

this.mocker.registerMockComponent(Environment.class);

133

this.mocker.registerMockComponent(ObservationManager.class);

134

this.mocker.registerMockComponent(ConfigurationSource.class, XWikiCfgConfigurationSource.ROLEHINT);

135

136

Utils.setComponentManager(mocker);

137

xwiki = new XWiki();

138

this.context.setWiki(this.xwiki);

139

140

this.storeMock = mock(XWikiStoreInterface.class);

141

xwiki.setStore(storeMock);

142

143

XWikiVersioningStoreInterface versioningStore = mock(XWikiVersioningStoreInterface.class);

144

xwiki.setVersioningStore(versioningStore);

145

146

this.xwikiCfgConfigurationSource = this.mocker.registerMockComponent(ConfigurationSource.class, "xwikicfg");

}

/**

* Verify that attachment versions are not incremented when a document is copied.

151

152

* @see <a href="http://jira.xwiki.org/browse/XWIKI-8157">XWIKI-8157: The "Copy Page" action adds an extra version

153

* to the attached file</a>

154

155

@Test

156

public void copyDocumentPreservesAttachmentsVersion() throws Exception

157

{

158

DocumentReference targetReference = new DocumentReference("bar", "Space", "Target");

159

XWikiDocument target = mock(XWikiDocument.class);

160

when(target.isNew()).thenReturn(true);

161

when(target.getDocumentReference()).thenReturn(targetReference);

162

163

DocumentReference sourceReference = new DocumentReference("foo", "Space", "Source");

164

XWikiDocument source = mock(XWikiDocument.class);

165

when(source.copyDocument(targetReference, context)).thenReturn(target);

166

167

when(xwiki.getStore().loadXWikiDoc(any(XWikiDocument.class), same(context))).thenReturn(source, target);

168

169

Assert.assertTrue(xwiki.copyDocument(sourceReference, targetReference, context));

170

171

// The target document needs to be new in order for the attachment version to be preserved on save.

172

verify(target).setNew(true);

173

174

verify(xwiki.getStore()).saveXWikiDoc(target, context);

}

/**

* Verify that {@link XWiki#rollback(XWikiDocument, String, XWikiContext)} fires the right events.

179

180

@Test

181

public void rollbackFiresEvents() throws Exception

182

{

183

ObservationManager observationManager = mocker.getInstance(ObservationManager.class);

184

185

DocumentReference documentReference = new DocumentReference("wiki", "Space", "Page");

186

XWikiDocument document = mock(XWikiDocument.class);

187

when(document.getDocumentReference()).thenReturn(documentReference);

188

189

XWikiDocument originalDocument = mock(XWikiDocument.class);

190

// Mark the document as existing so that the roll-back method will fire an update event.

191

when(originalDocument.isNew()).thenReturn(false);

192

193

XWikiDocument result = mock(XWikiDocument.class);

194

when(result.clone()).thenReturn(result);

195

when(result.getDocumentReference()).thenReturn(documentReference);

196

when(result.getOriginalDocument()).thenReturn(originalDocument);

197

198

String revision = "3.5";

199

when(xwiki.getVersioningStore().loadXWikiDoc(document, revision, context)).thenReturn(result);

200

201

this.mocker.registerMockComponent(ContextualLocalizationManager.class);

202

203

xwiki.rollback(document, revision, context);

204

205

verify(observationManager).notify(new DocumentRollingBackEvent(documentReference, revision), result, context);

206

verify(observationManager).notify(new DocumentUpdatingEvent(documentReference), result, context);

207

verify(observationManager).notify(new DocumentUpdatedEvent(documentReference), result, context);

208

verify(observationManager).notify(new DocumentRolledBackEvent(documentReference, revision), result, context);

}

/**

* @see "XWIKI-9399: Attachment version is incremented when a document is rolled back even if the attachment did not

* change"

@Test

public void rollbackDoesNotSaveUnchangedAttachment() throws Exception

217

{

218

String version = "1.1";

219

String fileName = "logo.png";

220

Date date = new Date();

221

XWikiAttachment currentAttachment = mock(XWikiAttachment.class);

222

when(currentAttachment.getAttachmentRevision(version, context)).thenReturn(currentAttachment);

223

when(currentAttachment.getDate()).thenReturn(new Timestamp(date.getTime()));

224

when(currentAttachment.getVersion()).thenReturn(version);

225

when(currentAttachment.getFilename()).thenReturn(fileName);

226

227

XWikiAttachment oldAttachment = mock(XWikiAttachment.class);

228

when(oldAttachment.getFilename()).thenReturn(fileName);

229

when(oldAttachment.getVersion()).thenReturn(version);

230

when(oldAttachment.getDate()).thenReturn(date);

231

232

DocumentReference documentReference = new DocumentReference("wiki", "Space", "Page");

233

XWikiDocument document = mock(XWikiDocument.class);

234

when(document.getDocumentReference()).thenReturn(documentReference);

235

when(document.getAttachmentList()).thenReturn(Arrays.asList(currentAttachment));

236

when(document.getAttachment(fileName)).thenReturn(currentAttachment);

237

238

XWikiDocument result = mock(XWikiDocument.class);

239

when(result.clone()).thenReturn(result);

240

when(result.getDocumentReference()).thenReturn(documentReference);

241

when(result.getAttachmentList()).thenReturn(Arrays.asList(oldAttachment));

242

when(result.getAttachment(fileName)).thenReturn(oldAttachment);

243

244

String revision = "3.5";

245

when(xwiki.getVersioningStore().loadXWikiDoc(document, revision, context)).thenReturn(result);

246

247

AttachmentRecycleBinStore attachmentRecycleBinStore = mock(AttachmentRecycleBinStore.class);

248

xwiki.setAttachmentRecycleBinStore(attachmentRecycleBinStore);

249

250

DocumentReference reference = document.getDocumentReference();

251

this.mocker.registerMockComponent(ContextualLocalizationManager.class);

252

when(xwiki.getStore().loadXWikiDoc(any(XWikiDocument.class), same(context)))

253

.thenReturn(new XWikiDocument(reference));

254

255

xwiki.rollback(document, revision, context);

256

257

verify(attachmentRecycleBinStore, never()).saveToRecycleBin(same(currentAttachment), any(String.class),

258

any(Date.class), same(context), eq(true));

259

verify(oldAttachment, never()).setMetaDataDirty(true);

}

@Test

public void deleteAllDocumentsAndWithoutSendingToTrash() throws Exception

264

{

265

XWiki xwiki = new XWiki();

266

267

XWikiDocument document = mock(XWikiDocument.class);

268

DocumentReference reference = new DocumentReference("wiki", "space", "page");

269

when(document.getDocumentReference()).thenReturn(reference);

270

271

// Make sure we have a trash for the test.

272

XWikiRecycleBinStoreInterface recycleBinStoreInterface = mock(XWikiRecycleBinStoreInterface.class);

273

xwiki.setRecycleBinStore(recycleBinStoreInterface);

274

when(xwikiCfgConfigurationSource.getProperty("xwiki.recyclebin", "1")).thenReturn("1");

275

276

// Configure the mocked Store to later verify if it's called

277

XWikiStoreInterface storeInterface = mock(XWikiStoreInterface.class);

278

xwiki.setStore(storeInterface);

279

XWikiContext xwikiContext = mock(XWikiContext.class);

280

281

xwiki.deleteAllDocuments(document, false, xwikiContext);

282

283

// Verify that saveToRecycleBin is never called since otherwise it would mean the doc has been saved in the

284

// trash

285

verify(recycleBinStoreInterface, never()).saveToRecycleBin(any(XWikiDocument.class), any(String.class),

286

any(Date.class), any(XWikiContext.class), any(Boolean.class));

287

288

// Verify that deleteXWikiDoc() is called

289

verify(storeInterface).deleteXWikiDoc(document, xwikiContext);

}

@Test

public void deleteDocument() throws Exception

294

{

295

final DocumentReference documentReference = new DocumentReference("wiki", "Space", "Page");

296

XWikiDocument document = mock(XWikiDocument.class);

297

when(document.getDocumentReference()).thenReturn(documentReference);

298

299

final XWikiDocument originalDocument = mock(XWikiDocument.class);

300

when(document.getOriginalDocument()).thenReturn(originalDocument);

301

302

this.xwiki.deleteDocument(document, this.context);

303

304

ObservationManager observation = this.mocker.getInstance(ObservationManager.class);

305

306

ArgumentMatcher<XWikiDocument> matcher = new ArgumentMatcher<XWikiDocument>()

307

{

308

@Override

309

public boolean matches(XWikiDocument argument)

310

{

311

return argument.getDocumentReference().equals(documentReference)

312

&& argument.getOriginalDocument() == originalDocument;

}

};

// Make sure the right events have been sent

317

verify(observation).notify(eq(new DocumentDeletingEvent(documentReference)), argThat(matcher),

318

same(this.context));

319

verify(observation).notify(eq(new DocumentDeletedEvent(documentReference)), argThat(matcher),

320

same(this.context));

321

322

verifyNoMoreInteractions(observation);

}

@Test

public void getPlainUserName() throws XWikiException

327

{

328

XWikiDocument document = mock(XWikiDocument.class);

329

DocumentReference userReference = new DocumentReference("wiki", "XWiki", "user");

330

when(document.getDocumentReference()).thenReturn(userReference);

331

when(this.storeMock.loadXWikiDoc(any(XWikiDocument.class), any(XWikiContext.class))).thenReturn(document);

332

BaseObject userObject = mock(BaseObject.class);

333

when(document.getObject("XWiki.XWikiUsers")).thenReturn(userObject);

334

335

when(userObject.getStringValue("first_name")).thenReturn("first<name");

336

when(userObject.getStringValue("last_name")).thenReturn("last'name");

337

assertEquals("first<name last'name", xwiki.getPlainUserName(userReference, context));

338

339

when(userObject.getStringValue("first_name")).thenReturn("first<name");

340

when(userObject.getStringValue("last_name")).thenReturn("");

341

assertEquals("first<name", xwiki.getPlainUserName(userReference, context));

342

343

when(userObject.getStringValue("first_name")).thenReturn("");

344

when(userObject.getStringValue("last_name")).thenReturn("last'name");

345

assertEquals("last'name", xwiki.getPlainUserName(userReference, context));

}

@Test

public void getURLWithDotsAndBackslashInSpaceName() throws Exception

350

{

351

XWikiURLFactory urlFactory = mock(XWikiURLFactory.class);

352

context.setURLFactory(urlFactory);

353

354

DocumentReference reference = new DocumentReference("wiki", Arrays.asList("space.withdot.and\\and:"), "page");

355

356

EntityReferenceSerializer<String> serializer =

357

this.mocker.getInstance(EntityReferenceSerializer.TYPE_STRING, "local");

358

when(serializer.serialize(reference.getLastSpaceReference())).thenReturn("somescapedspace");

359

360

this.xwiki.getURL(reference, "view", null, null, context);

361

362

verify(urlFactory).createURL("somescapedspace", "page", "view", null, null, "wiki", context);

}

@Test

public void getURLWithLocale() throws Exception

367

{

368

XWikiURLFactory urlFactory = mock(XWikiURLFactory.class);

369

context.setURLFactory(urlFactory);

370

371

DocumentReference reference = new DocumentReference("wiki", "Space", "Page", Locale.FRENCH);

372

373

EntityReferenceSerializer<String> serializer =

374

this.mocker.getInstance(EntityReferenceSerializer.TYPE_STRING, "local");

375

when(serializer.serialize(reference.getLastSpaceReference())).thenReturn("Space");

376

377

this.xwiki.getURL(reference, "view", null, null, context);

378

verify(urlFactory).createURL("Space", "Page", "view", "language=fr", null, "wiki", context);

379

380

this.xwiki.getURL(reference, "view", "language=ro", null, context);

381

verify(urlFactory).createURL("Space", "Page", "view", "language=ro&language=fr", null, "wiki", context);

}

@Test

public void getEntityURLWithDefaultAction() throws Exception

386

{

387

DocumentReference documentReference = new DocumentReference("tennis", Arrays.asList("Path", "To"), "Success");

388

AttachmentReference attachmentReference = new AttachmentReference("image.png", documentReference);

389

390

XWikiURLFactory urlFactory = mock(XWikiURLFactory.class);

391

context.setURLFactory(urlFactory);

392

393

EntityReferenceSerializer<String> localSerializer =

394

this.mocker.getInstance(EntityReferenceSerializer.TYPE_STRING, "local");

395

when(localSerializer.serialize(documentReference.getLastSpaceReference())).thenReturn("Path.To");

396

397

// Document Entity

398

DocumentReferenceResolver<EntityReference> documentResolver =

399

this.mocker.registerMockComponent(DocumentReferenceResolver.TYPE_REFERENCE, "currentgetdocument");

400

when(documentResolver.resolve(documentReference)).thenReturn(documentReference);

401

402

this.xwiki.getURL(documentReference, this.context);

403

verify(urlFactory).createURL("Path.To", "Success", "view", null, null, "tennis", this.context);

404

405

// Attachment Entity

406

AttachmentReferenceResolver<EntityReference> attachmentResolver =

407

this.mocker.registerMockComponent(AttachmentReferenceResolver.TYPE_REFERENCE, "current");

408

when(attachmentResolver.resolve(attachmentReference)).thenReturn(attachmentReference);

409

410

this.xwiki.getURL(attachmentReference, this.context);

411

verify(urlFactory).createAttachmentURL("image.png", "Path.To", "Success", "download", null, "tennis",

this.context);

}

@Test

public void getSpacePreference() throws Exception

417

{

418

this.mocker.registerMockComponent(ConfigurationSource.class, "wiki");

419

ConfigurationSource spaceConfiguration = this.mocker.registerMockComponent(ConfigurationSource.class, "space");

420

421

when(this.xwikiCfgConfigurationSource.getProperty(any(), anyString())).then(new Answer<String>()

422

{

423

@Override

424

public String answer(InvocationOnMock invocation) throws Throwable

425

{

426

return invocation.getArgument(1);

}

});

WikiReference wikiReference = new WikiReference("wiki");

431

SpaceReference space1Reference = new SpaceReference("space1", wikiReference);

432

SpaceReference space2Reference = new SpaceReference("space2", space1Reference);

433

434

// Without preferences and current doc

435

436

assertEquals("", this.xwiki.getSpacePreference("pref", this.context));

437

assertEquals("defaultvalue", this.xwiki.getSpacePreference("pref", "defaultvalue", this.context));

438

assertEquals("", this.xwiki.getSpacePreference("pref", space2Reference, this.context));

439

assertEquals("defaultvalue",

440

this.xwiki.getSpacePreference("pref", space2Reference, "defaultvalue", this.context));

441

442

// Without preferences but with current doc

443

444

this.context.setDoc(new XWikiDocument(new DocumentReference("document", space2Reference)));

445

446

assertEquals("", this.xwiki.getSpacePreference("pref", this.context));

447

assertEquals("defaultvalue", this.xwiki.getSpacePreference("pref", "defaultvalue", this.context));

448

assertEquals("", this.xwiki.getSpacePreference("pref", space2Reference, this.context));

449

assertEquals("defaultvalue",

450

this.xwiki.getSpacePreference("pref", space2Reference, "defaultvalue", this.context));

// With preferences

final Map<String, Map<String, String>> spacesPreferences = new HashMap<>();

455

Map<String, String> space1Preferences = new HashMap<>();

456

space1Preferences.put("pref", "prefvalue1");

457

space1Preferences.put("pref1", "pref1value1");

458

Map<String, String> space2Preferences = new HashMap<>();

459

space2Preferences.put("pref", "prefvalue2");

460

space2Preferences.put("pref2", "pref2value2");

461

spacesPreferences.put(space1Reference.getName(), space1Preferences);

462

spacesPreferences.put(space2Reference.getName(), space2Preferences);

463

464

when(spaceConfiguration.getProperty(any(), same(String.class))).then(new Answer<String>()

465

{

466

@Override

467

public String answer(InvocationOnMock invocation) throws Throwable

468

{

469

if (context.getDoc() != null) {

470

Map<String, String> spacePreferences =

471

spacesPreferences.get(context.getDoc().getDocumentReference().getParent().getName());

472

if (spacePreferences != null) {

473

return spacePreferences.get(invocation.getArgument(0));

}

}

return null;

}

});

this.context.setDoc(new XWikiDocument(new DocumentReference("document", space1Reference)));

482

assertEquals("prefvalue1", this.xwiki.getSpacePreference("pref", this.context));

483

assertEquals("prefvalue1", this.xwiki.getSpacePreference("pref", "defaultvalue", this.context));

484

assertEquals("pref1value1", this.xwiki.getSpacePreference("pref1", this.context));

485

assertEquals("", this.xwiki.getSpacePreference("pref2", this.context));

486

487

this.context.setDoc(new XWikiDocument(new DocumentReference("document", space2Reference)));

488

assertEquals("prefvalue2", this.xwiki.getSpacePreference("pref", this.context));

489

assertEquals("prefvalue2", this.xwiki.getSpacePreference("pref", "defaultvalue", this.context));

490

assertEquals("pref1value1", this.xwiki.getSpacePreference("pref1", this.context));

491

assertEquals("pref2value2", this.xwiki.getSpacePreference("pref2", this.context));

492

493

assertEquals("", this.xwiki.getSpacePreference("nopref", space1Reference, this.context));

494

assertEquals("defaultvalue",

495

this.xwiki.getSpacePreference("nopref", space1Reference, "defaultvalue", this.context));

496

assertEquals("prefvalue1", this.xwiki.getSpacePreference("pref", space1Reference, this.context));

497

assertEquals("prefvalue1",

498

this.xwiki.getSpacePreference("pref", space1Reference, "defaultvalue", this.context));

499

assertEquals("pref1value1", this.xwiki.getSpacePreference("pref1", space1Reference, this.context));

500

assertEquals("", this.xwiki.getSpacePreference("pref2", space1Reference, this.context));

501

502

assertEquals("", this.xwiki.getSpacePreference("nopref", space2Reference, this.context));

503

assertEquals("defaultvalue",

504

this.xwiki.getSpacePreference("nopref", space2Reference, "defaultvalue", this.context));

505

assertEquals("prefvalue2", this.xwiki.getSpacePreference("pref", space2Reference, this.context));

506

assertEquals("prefvalue2",

507

this.xwiki.getSpacePreference("pref", space2Reference, "defaultvalue", this.context));

508

assertEquals("pref1value1", this.xwiki.getSpacePreference("pref1", space2Reference, this.context));

509

assertEquals("pref2value2", this.xwiki.getSpacePreference("pref2", space2Reference, this.context));

510

}

511

}

XWiki Enterprise - Parent POM 9.0-SNAPSHOT

File XWikiMockitoTest.java

Code metrics

Classes

Class XWikiMockitoTest

Contributing tests

Contributing tests

Source view