You need to set up the spy before the method is called. Jasmine spys wrap function to determine when they are called and what they get called with. The method must be wrapped before the spied on method is called in order to capture the information. Try changing your test to match the following:

it('should foobar', () => {
    spyOn(component, 'bar');
    component.foo();
    expect(component.bar).toHaveBeenCalled();
})

I take a slightly different approach and use inject itself to get hold of the service instance through DI instead. So your test would look like:

import {
  describe, 
  expect, 
  it,
  tick,
  inject,
  fakeAsync,
  TestComponentBuilder,
  ComponentFixture,
  addProviders
} from 'angular2/testing';

import { Component, provide } from '@angular/core';

import {UserListComponent} from './user-list.component';

import {UserService} from './user.service';
import {MockUserService} from './user.service.mock';

describe('When loading the UserListComponent', () => {

  beforeEach(() => addProviders([
      {provide: UserService, useClass: MockUserService}
  ]));

  it('should call the getAllUsers method from the UserService', 
    inject([TestComponentBuilder, UserService], fakeAsync((tcb: TestComponentBuilder, mockUserService: UserService) => {
      spyOn(mockUserService, 'getAllUsers');

      tcb
        .createAsync(UserListComponent)
        .then((fixture: ComponentFixture) => {
          tick();
          fixture.detectChanges();
          expect(mockUserService.getAllUsers).toHaveBeenCalled();
        });
    }))
  );

  it('should show one mocked user', 
    inject([TestComponentBuilder, UserService], fakeAsync((tcb: TestComponentBuilder, mockUserService: UserService) => {
      mockUserService.setResponse([{
        username: 'ryan',
        email: '[email protected]'
      }]);

      tcb
        .createAsync(UserListComponent)
        .then((fixture: ComponentFixture) => {
          tick();
          fixture.detectChanges();
          let compiled = fixture.debugElement.nativeElement;
          expect(compiled.querySelector('div:nth-child(1) .username')).toHaveText('Username: ryan');
          expect(compiled.querySelector('div:nth-child(1) .email')).toHaveText('Email: [email protected]');
        });
    }))
  );

});

Edit for Angular 4

The latest docs have a simpler way of getting hold of a service using the component's injector:

  fixture = TestBed.createComponent(TestComponent);
  component = fixture.componentInstance;
  const mockService = fixture.debugElement.injector.get(MyService);

Edit for Angular 5+

  import { Component, Injector, Type } from '@angular/core';
  ...

  fixture = TestBed.createComponent(TestComponent);
  component = fixture.componentInstance;
  const mockService = fixture.debugElement.injector.get<MyService>(MyService as Type<MyService>);

I had a stubbed child component where I wanted to confirm that certain functions on it were being called per my component's logic.

I was able to achieve this with the following setup.

Stub component:

@Component({selector: 'child-component', template: ''})
class ChildComponentStub {
  someFunction() { /* ... */}
}

Test stage:

it('should spy on a child component function', () => {
  const childComponent =
           fixture.debugElement.query(By.directive(ChildComponentStub))
               .componentInstance;

  const functionSpy = spyOn(childComponent, 'someFunction').and.callThrough();
       
  // test logic that causes someFunction to be called

  expect(functionSpy).toHaveBeenCalled();
});

(Based on this answer that explains how to get a reference to a child component)

The only way you can spy a method of SUT is to update its prototype before the creation of an instance of it:

  let backup: any;
  beforeEach(() => {
    backup = TargetComponent.prototype.func;
    TargetComponent.prototype.func = jasmine.createSpy().and.returnValue('mock');
  });

  afterEach(() => {
    TargetComponent.prototype.func = backup;
  });

An example is here: https://codesandbox.io/s/objective-scott-euy6dz?file=/src/test.spec.ts

Oke It is fixed! thanks to the answer from @Supamiu

Incase someone will need it in the future:

Move the initialization into ngOnInit, remove fixture.detectChanges(); from beforeEach and execute it in the test. So:

Comp:

constructor(private someService: SomeService) { }

ngOnInit() {
    if (this.someService.someData()) {
        this.someMethod();
    } else {
        console.log('keep kalm!');
    }
}

test:

beforeEach(() => {
    fixture = TestBed.createComponent(SomeComponent);
    component = fixture.componentInstance;
    // fixture.detectChanges(); <<< Remove this
});

it('method should be called', () => {
    spyOn(component, 'someMethod'); 
    fixture.detectChanges(); // trigger ngOnInit here

    expect(component.someMethod).toHaveBeenCalled(); 
});

to mock a service in component's constructor, you need provide the mock before TestBed.createComponent

for example

beforeEach(() => {
  mockService = TestBed.get(Service); 
  spyOn(mockService, 'getSomeValue').and.returnValue({value});
  fixture = TestBed.createComponent(MyComponent);
  component  = fixture.componentInstance;
})

1. As I have used providers in the Profile Component, can I inject the Profileervice in the profile.component.spec.ts file as it will create two instance of the same service..??

Answer: You should create a Stub for the service to replace dependency on actual ProfileService using useClass

export class ProfileServiceStub {
    getData(id: string) {
       return of({some_obj: "value"})
    }
}

and in spec.ts

    beforeEach(async(() => {
        TestBed.configureTestingModule({
            imports: [HttpClientTestingModule, ReactiveFormsModule, RouterTestingModule],
            declarations: [ProfileComponent],
            providers: [ {provide: ProfileService , useClass: ProfileServiceStub } ], // <-- useclass here
            schemas: [NO_ERRORS_SCHEMA]
        }).compileComponents();

2. How to spy on login() and getData() of ProfileService as below statement is not working...?

Answer: Make the service public in component constructor as below:

constructor(public profileService: ProfileService) { }

I would strongly recommend you to read my article on something similar where I have tested the component

I actually tried to spy on the wrong instance of a service. Right service should be inside my GalleryComponent and not inside TestHostComponent.

I ended up with creating GalleryService mock class:

class MockService extends GalleryService {
    getPhotos(galleryId: number) {
      return Observable.of(fakePhotos);
    }
}

and overriding component providers before compiling components:

beforeEach(async(() => {
    TestBed.overrideComponent(GalleryComponent, {
      set: {providers: [{provide: GalleryService, useClass: MockService}]}
    });

    // ...SKIP
}));

And now I do not need to spy on a service at all.